ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/configure
(Generate patch)

Comparing trunk/configure (file contents):
Revision 1281 by gezelter, Wed Jul 16 02:34:05 2008 UTC vs.
Revision 1373 by gezelter, Tue Oct 20 13:13:45 2009 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.62 for OOPSE 4.0.
3 > # Generated by GNU Autoconf 2.64 for OOPSE 4.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
7   # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
8 < # 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
8 > # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software
9 > # Foundation, Inc.
10 > #
11   # This configure script is free software; the Free Software Foundation
12   # gives unlimited permission to copy, distribute and modify it.
13 < ## --------------------- ##
14 < ## M4sh Initialization.  ##
15 < ## --------------------- ##
13 > ## -------------------- ##
14 > ## M4sh Initialization. ##
15 > ## -------------------- ##
16  
17   # Be more Bourne compatible
18   DUALCASE=1; export DUALCASE # for MKS sh
19 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
19 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
20    emulate sh
21    NULLCMD=:
22    # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# Line 22 | Line 24 | else
24    alias -g '${1+"$@"}'='"$@"'
25    setopt NO_GLOB_SUBST
26   else
27 <  case `(set -o) 2>/dev/null` in
28 <  *posix*) set -o posix ;;
27 >  case `(set -o) 2>/dev/null` in #(
28 >  *posix*) :
29 >    set -o posix ;; #(
30 >  *) :
31 >     ;;
32   esac
28 –
33   fi
34  
35  
32 –
33 –
34 – # PATH needs CR
35 – # Avoid depending upon Character Ranges.
36 – as_cr_letters='abcdefghijklmnopqrstuvwxyz'
37 – as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
38 – as_cr_Letters=$as_cr_letters$as_cr_LETTERS
39 – as_cr_digits='0123456789'
40 – as_cr_alnum=$as_cr_Letters$as_cr_digits
41 –
36   as_nl='
37   '
38   export as_nl
# Line 46 | Line 40 | as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
40   as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
41   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
42   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
43 < if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
43 > # Prefer a ksh shell builtin over an external printf program on Solaris,
44 > # but without wasting forks for bash or zsh.
45 > if test -z "$BASH_VERSION$ZSH_VERSION" \
46 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
47 >  as_echo='print -r --'
48 >  as_echo_n='print -rn --'
49 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
50    as_echo='printf %s\n'
51    as_echo_n='printf %s'
52   else
# Line 57 | Line 57 | else
57      as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
58      as_echo_n_body='eval
59        arg=$1;
60 <      case $arg in
60 >      case $arg in #(
61        *"$as_nl"*)
62          expr "X$arg" : "X\\(.*\\)$as_nl";
63          arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
# Line 80 | Line 80 | fi
80    }
81   fi
82  
83 – # Support unset when possible.
84 – if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
85 –  as_unset=unset
86 – else
87 –  as_unset=false
88 – fi
83  
90 –
84   # IFS
85   # We need space, tab and new line, in precisely that order.  Quoting is
86   # there to prevent editors from complaining about space-tab.
# Line 96 | Line 89 | IFS=" ""       $as_nl"
89   IFS=" ""        $as_nl"
90  
91   # Find who we are.  Look in the path if we contain no directory separator.
92 < case $0 in
92 > case $0 in #((
93    *[\\/]* ) as_myself=$0 ;;
94    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
95   for as_dir in $PATH
96   do
97    IFS=$as_save_IFS
98    test -z "$as_dir" && as_dir=.
99 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
100 < done
99 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
100 >  done
101   IFS=$as_save_IFS
102  
103       ;;
# Line 116 | Line 109 | if test ! -f "$as_myself"; then
109   fi
110   if test ! -f "$as_myself"; then
111    $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
112 <  { (exit 1); exit 1; }
112 >  exit 1
113   fi
114  
115 < # Work around bugs in pre-3.0 UWIN ksh.
116 < for as_var in ENV MAIL MAILPATH
117 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
115 > # Unset variables that we do not need and which cause bugs (e.g. in
116 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
117 > # suppresses any "Segmentation fault" message there.  '((' could
118 > # trigger a bug in pdksh 5.2.14.
119 > for as_var in BASH_ENV ENV MAIL MAILPATH
120 > do eval test x\${$as_var+set} = xset \
121 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
122   done
123   PS1='$ '
124   PS2='> '
# Line 133 | Line 130 | export LANGUAGE
130   LANGUAGE=C
131   export LANGUAGE
132  
133 < # Required to use basename.
134 < if expr a : '\(a\)' >/dev/null 2>&1 &&
138 <   test "X`expr 00001 : '.*\(...\)'`" = X001; then
139 <  as_expr=expr
140 < else
141 <  as_expr=false
142 < fi
133 > # CDPATH.
134 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
135  
136 < if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
137 <  as_basename=basename
136 > if test "x$CONFIG_SHELL" = x; then
137 >  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
138 >  emulate sh
139 >  NULLCMD=:
140 >  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
141 >  # is contrary to our usage.  Disable this feature.
142 >  alias -g '\${1+\"\$@\"}'='\"\$@\"'
143 >  setopt NO_GLOB_SUBST
144   else
145 <  as_basename=false
145 >  case \`(set -o) 2>/dev/null\` in #(
146 >  *posix*) :
147 >    set -o posix ;; #(
148 >  *) :
149 >     ;;
150 > esac
151   fi
152 + "
153 +  as_required="as_fn_return () { (exit \$1); }
154 + as_fn_success () { as_fn_return 0; }
155 + as_fn_failure () { as_fn_return 1; }
156 + as_fn_ret_success () { return 0; }
157 + as_fn_ret_failure () { return 1; }
158  
159 + exitcode=0
160 + as_fn_success || { exitcode=1; echo as_fn_success failed.; }
161 + as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
162 + as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
163 + as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
164 + if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
165  
166 < # Name of the executable.
167 < as_me=`$as_basename -- "$0" ||
168 < $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
169 <         X"$0" : 'X\(//\)$' \| \
170 <         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
171 < $as_echo X/"$0" |
172 <    sed '/^.*\/\([^/][^/]*\)\/*$/{
173 <            s//\1/
174 <            q
175 <          }
161 <          /^X\/\(\/\/\)$/{
162 <            s//\1/
163 <            q
164 <          }
165 <          /^X\/\(\/\).*/{
166 <            s//\1/
167 <            q
168 <          }
169 <          s/.*/./; q'`
170 <
171 < # CDPATH.
172 < $as_unset CDPATH
173 <
174 <
175 < if test "x$CONFIG_SHELL" = x; then
176 <  if (eval ":") 2>/dev/null; then
166 > else
167 >  exitcode=1; echo positional parameters were not saved.
168 > fi
169 > test x\$exitcode = x0 || exit 1"
170 >  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
171 >  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
172 >  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
173 >  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
174 > test \$(( 1 + 1 )) = 2 || exit 1"
175 >  if (eval "$as_required") 2>/dev/null; then :
176    as_have_required=yes
177   else
178    as_have_required=no
179   fi
180 +  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
181  
182 –  if test $as_have_required = yes &&     (eval ":
183 – (as_func_return () {
184 –  (exit \$1)
185 – }
186 – as_func_success () {
187 –  as_func_return 0
188 – }
189 – as_func_failure () {
190 –  as_func_return 1
191 – }
192 – as_func_ret_success () {
193 –  return 0
194 – }
195 – as_func_ret_failure () {
196 –  return 1
197 – }
198 –
199 – exitcode=0
200 – if as_func_success; then
201 –  :
182   else
183 <  exitcode=1
184 <  echo as_func_success failed.
205 < fi
206 <
207 < if as_func_failure; then
208 <  exitcode=1
209 <  echo as_func_failure succeeded.
210 < fi
211 <
212 < if as_func_ret_success; then
213 <  :
214 < else
215 <  exitcode=1
216 <  echo as_func_ret_success failed.
217 < fi
218 <
219 < if as_func_ret_failure; then
220 <  exitcode=1
221 <  echo as_func_ret_failure succeeded.
222 < fi
223 <
224 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
225 <  :
226 < else
227 <  exitcode=1
228 <  echo positional parameters were not saved.
229 < fi
230 <
231 < test \$exitcode = 0) || { (exit 1); exit 1; }
232 <
233 < (
234 <  as_lineno_1=\$LINENO
235 <  as_lineno_2=\$LINENO
236 <  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
237 <  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
238 < ") 2> /dev/null; then
239 <  :
240 < else
241 <  as_candidate_shells=
242 <    as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
183 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
184 > as_found=false
185   for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
186   do
187    IFS=$as_save_IFS
188    test -z "$as_dir" && as_dir=.
189 <  case $as_dir in
189 >  as_found=:
190 >  case $as_dir in #(
191           /*)
192             for as_base in sh bash ksh sh5; do
193 <             as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
193 >             # Try only shells that exist, to save several forks.
194 >             as_shell=$as_dir/$as_base
195 >             if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
196 >                    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
197 >  CONFIG_SHELL=$as_shell as_have_required=yes
198 >                   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
199 >  break 2
200 > fi
201 > fi
202             done;;
203         esac
204 +  as_found=false
205   done
206 + $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
207 +              { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
208 +  CONFIG_SHELL=$SHELL as_have_required=yes
209 + fi; }
210   IFS=$as_save_IFS
211  
256 –
257 –      for as_shell in $as_candidate_shells $SHELL; do
258 –         # Try only shells that exist, to save several forks.
259 –         if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
260 –                { ("$as_shell") 2> /dev/null <<\_ASEOF
261 – if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
262 –  emulate sh
263 –  NULLCMD=:
264 –  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
265 –  # is contrary to our usage.  Disable this feature.
266 –  alias -g '${1+"$@"}'='"$@"'
267 –  setopt NO_GLOB_SUBST
268 – else
269 –  case `(set -o) 2>/dev/null` in
270 –  *posix*) set -o posix ;;
271 – esac
272 –
273 – fi
274 –
275 –
276 – :
277 – _ASEOF
278 – }; then
279 –  CONFIG_SHELL=$as_shell
280 –               as_have_required=yes
281 –               if { "$as_shell" 2> /dev/null <<\_ASEOF
282 – if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
283 –  emulate sh
284 –  NULLCMD=:
285 –  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
286 –  # is contrary to our usage.  Disable this feature.
287 –  alias -g '${1+"$@"}'='"$@"'
288 –  setopt NO_GLOB_SUBST
289 – else
290 –  case `(set -o) 2>/dev/null` in
291 –  *posix*) set -o posix ;;
292 – esac
293 –
294 – fi
295 –
296 –
297 – :
298 – (as_func_return () {
299 –  (exit $1)
300 – }
301 – as_func_success () {
302 –  as_func_return 0
303 – }
304 – as_func_failure () {
305 –  as_func_return 1
306 – }
307 – as_func_ret_success () {
308 –  return 0
309 – }
310 – as_func_ret_failure () {
311 –  return 1
312 – }
212  
213 < exitcode=0
214 < if as_func_success; then
215 <  :
216 < else
217 <  exitcode=1
218 <  echo as_func_success failed.
213 >      if test "x$CONFIG_SHELL" != x; then :
214 >  # We cannot yet assume a decent shell, so we have to provide a
215 >        # neutralization value for shells without unset; and this also
216 >        # works around shells that cannot unset nonexistent variables.
217 >        BASH_ENV=/dev/null
218 >        ENV=/dev/null
219 >        (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
220 >        export CONFIG_SHELL
221 >        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
222   fi
223  
224 < if as_func_failure; then
225 <  exitcode=1
226 <  echo as_func_failure succeeded.
224 >    if test x$as_have_required = xno; then :
225 >  $as_echo "$0: This script requires a shell more modern than all"
226 >  $as_echo "$0: the shells that I found on your system."
227 >  if test x${ZSH_VERSION+set} = xset ; then
228 >    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
229 >    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
230 >  else
231 >    $as_echo "$0: Please tell bug-autoconf@gnu.org and gezelter@nd.edu
232 > $0: about your system, including any error possibly output
233 > $0: before this message. Then install a modern shell, or
234 > $0: manually run the script under such a shell if you do
235 > $0: have one."
236 >  fi
237 >  exit 1
238   fi
326 –
327 – if as_func_ret_success; then
328 –  :
329 – else
330 –  exitcode=1
331 –  echo as_func_ret_success failed.
239   fi
333 –
334 – if as_func_ret_failure; then
335 –  exitcode=1
336 –  echo as_func_ret_failure succeeded.
240   fi
241 + SHELL=${CONFIG_SHELL-/bin/sh}
242 + export SHELL
243 + # Unset more variables known to interfere with behavior of common tools.
244 + CLICOLOR_FORCE= GREP_OPTIONS=
245 + unset CLICOLOR_FORCE GREP_OPTIONS
246  
247 < if ( set x; as_func_ret_success y && test x = "$1" ); then
248 <  :
249 < else
250 <  exitcode=1
251 <  echo positional parameters were not saved.
252 < fi
247 > ## --------------------- ##
248 > ## M4sh Shell Functions. ##
249 > ## --------------------- ##
250 > # as_fn_unset VAR
251 > # ---------------
252 > # Portably unset VAR.
253 > as_fn_unset ()
254 > {
255 >  { eval $1=; unset $1;}
256 > }
257 > as_unset=as_fn_unset
258  
259 < test $exitcode = 0) || { (exit 1); exit 1; }
259 > # as_fn_set_status STATUS
260 > # -----------------------
261 > # Set $? to STATUS, without forking.
262 > as_fn_set_status ()
263 > {
264 >  return $1
265 > } # as_fn_set_status
266  
267 < (
268 <  as_lineno_1=$LINENO
269 <  as_lineno_2=$LINENO
270 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
271 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
267 > # as_fn_exit STATUS
268 > # -----------------
269 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
270 > as_fn_exit ()
271 > {
272 >  set +e
273 >  as_fn_set_status $1
274 >  exit $1
275 > } # as_fn_exit
276  
277 < _ASEOF
278 < }; then
279 <  break
280 < fi
277 > # as_fn_mkdir_p
278 > # -------------
279 > # Create "$as_dir" as a directory, including parents if necessary.
280 > as_fn_mkdir_p ()
281 > {
282  
283 < fi
283 >  case $as_dir in #(
284 >  -*) as_dir=./$as_dir;;
285 >  esac
286 >  test -d "$as_dir" || eval $as_mkdir_p || {
287 >    as_dirs=
288 >    while :; do
289 >      case $as_dir in #(
290 >      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
291 >      *) as_qdir=$as_dir;;
292 >      esac
293 >      as_dirs="'$as_qdir' $as_dirs"
294 >      as_dir=`$as_dirname -- "$as_dir" ||
295 > $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
296 >         X"$as_dir" : 'X\(//\)[^/]' \| \
297 >         X"$as_dir" : 'X\(//\)$' \| \
298 >         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
299 > $as_echo X"$as_dir" |
300 >    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
301 >            s//\1/
302 >            q
303 >          }
304 >          /^X\(\/\/\)[^/].*/{
305 >            s//\1/
306 >            q
307 >          }
308 >          /^X\(\/\/\)$/{
309 >            s//\1/
310 >            q
311 >          }
312 >          /^X\(\/\).*/{
313 >            s//\1/
314 >            q
315 >          }
316 >          s/.*/./; q'`
317 >      test -d "$as_dir" && break
318 >    done
319 >    test -z "$as_dirs" || eval "mkdir $as_dirs"
320 >  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
321  
361 –      done
322  
323 <      if test "x$CONFIG_SHELL" != x; then
324 <  for as_var in BASH_ENV ENV
325 <        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
326 <        done
327 <        export CONFIG_SHELL
328 <        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
329 < fi
323 > } # as_fn_mkdir_p
324 > # as_fn_append VAR VALUE
325 > # ----------------------
326 > # Append the text in VALUE to the end of the definition contained in VAR. Take
327 > # advantage of any shell optimizations that allow amortized linear growth over
328 > # repeated appends, instead of the typical quadratic growth present in naive
329 > # implementations.
330 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
331 >  eval 'as_fn_append ()
332 >  {
333 >    eval $1+=\$2
334 >  }'
335 > else
336 >  as_fn_append ()
337 >  {
338 >    eval $1=\$$1\$2
339 >  }
340 > fi # as_fn_append
341  
342 + # as_fn_arith ARG...
343 + # ------------------
344 + # Perform arithmetic evaluation on the ARGs, and store the result in the
345 + # global $as_val. Take advantage of shells that can avoid forks. The arguments
346 + # must be portable across $(()) and expr.
347 + if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
348 +  eval 'as_fn_arith ()
349 +  {
350 +    as_val=$(( $* ))
351 +  }'
352 + else
353 +  as_fn_arith ()
354 +  {
355 +    as_val=`expr "$@" || test $? -eq 1`
356 +  }
357 + fi # as_fn_arith
358  
372 –    if test $as_have_required = no; then
373 –  echo This script requires a shell more modern than all the
374 –      echo shells that I found on your system.  Please install a
375 –      echo modern shell, or manually run the script under such a
376 –      echo shell if you do have one.
377 –      { (exit 1); exit 1; }
378 – fi
359  
360 + # as_fn_error ERROR [LINENO LOG_FD]
361 + # ---------------------------------
362 + # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
363 + # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
364 + # script with status $?, using 1 if that was 0.
365 + as_fn_error ()
366 + {
367 +  as_status=$?; test $as_status -eq 0 && as_status=1
368 +  if test "$3"; then
369 +    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
370 +    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
371 +  fi
372 +  $as_echo "$as_me: error: $1" >&2
373 +  as_fn_exit $as_status
374 + } # as_fn_error
375  
376 < fi
377 <
378 < fi
384 <
385 <
386 <
387 < (eval "as_func_return () {
388 <  (exit \$1)
389 < }
390 < as_func_success () {
391 <  as_func_return 0
392 < }
393 < as_func_failure () {
394 <  as_func_return 1
395 < }
396 < as_func_ret_success () {
397 <  return 0
398 < }
399 < as_func_ret_failure () {
400 <  return 1
401 < }
402 <
403 < exitcode=0
404 < if as_func_success; then
405 <  :
376 > if expr a : '\(a\)' >/dev/null 2>&1 &&
377 >   test "X`expr 00001 : '.*\(...\)'`" = X001; then
378 >  as_expr=expr
379   else
380 <  exitcode=1
408 <  echo as_func_success failed.
380 >  as_expr=false
381   fi
382  
383 < if as_func_failure; then
384 <  exitcode=1
413 <  echo as_func_failure succeeded.
414 < fi
415 <
416 < if as_func_ret_success; then
417 <  :
383 > if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
384 >  as_basename=basename
385   else
386 <  exitcode=1
420 <  echo as_func_ret_success failed.
386 >  as_basename=false
387   fi
388  
389 < if as_func_ret_failure; then
390 <  exitcode=1
425 <  echo as_func_ret_failure succeeded.
426 < fi
427 <
428 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
429 <  :
389 > if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
390 >  as_dirname=dirname
391   else
392 <  exitcode=1
432 <  echo positional parameters were not saved.
392 >  as_dirname=false
393   fi
394  
395 < test \$exitcode = 0") || {
396 <  echo No shell found that supports shell functions.
397 <  echo Please tell bug-autoconf@gnu.org about your system,
398 <  echo including any error possibly output before this message.
399 <  echo This can help us improve future autoconf versions.
400 <  echo Configuration will now proceed without shell functions.
401 < }
395 > as_me=`$as_basename -- "$0" ||
396 > $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
397 >         X"$0" : 'X\(//\)$' \| \
398 >         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
399 > $as_echo X/"$0" |
400 >    sed '/^.*\/\([^/][^/]*\)\/*$/{
401 >            s//\1/
402 >            q
403 >          }
404 >          /^X\/\(\/\/\)$/{
405 >            s//\1/
406 >            q
407 >          }
408 >          /^X\/\(\/\).*/{
409 >            s//\1/
410 >            q
411 >          }
412 >          s/.*/./; q'`
413  
414 + # Avoid depending upon Character Ranges.
415 + as_cr_letters='abcdefghijklmnopqrstuvwxyz'
416 + as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
417 + as_cr_Letters=$as_cr_letters$as_cr_LETTERS
418 + as_cr_digits='0123456789'
419 + as_cr_alnum=$as_cr_Letters$as_cr_digits
420  
421  
422 <  as_lineno_1=$LINENO
423 <  as_lineno_2=$LINENO
424 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
425 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
426 <
450 <  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
451 <  # uniformly replaced by the line number.  The first 'sed' inserts a
452 <  # line-number line after each line using $LINENO; the second 'sed'
453 <  # does the real work.  The second script uses 'N' to pair each
454 <  # line-number line with the line containing $LINENO, and appends
455 <  # trailing '-' during substitution so that $LINENO is not a special
456 <  # case at line end.
457 <  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
458 <  # scripts with optimization help from Paolo Bonzini.  Blame Lee
459 <  # E. McMahon (1931-1989) for sed's syntax.  :-)
422 >  as_lineno_1=$LINENO as_lineno_1a=$LINENO
423 >  as_lineno_2=$LINENO as_lineno_2a=$LINENO
424 >  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
425 >  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
426 >  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
427    sed -n '
428      p
429      /[$]LINENO/=
# Line 473 | Line 440 | test \$exitcode = 0") || {
440        s/-\n.*//
441      ' >$as_me.lineno &&
442    chmod +x "$as_me.lineno" ||
443 <    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
477 <   { (exit 1); exit 1; }; }
443 >    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
444  
445    # Don't try to exec as it changes $[0], causing all sort of problems
446    # (the dirname of $[0] is not the place where we might find the
# Line 484 | Line 450 | test \$exitcode = 0") || {
450    exit
451   }
452  
487 –
488 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
489 –  as_dirname=dirname
490 – else
491 –  as_dirname=false
492 – fi
493 –
453   ECHO_C= ECHO_N= ECHO_T=
454 < case `echo -n x` in
454 > case `echo -n x` in #(((((
455   -n*)
456 <  case `echo 'x\c'` in
456 >  case `echo 'xy\c'` in
457    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
458 <  *)   ECHO_C='\c';;
458 >  xy)  ECHO_C='\c';;
459 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
460 >       ECHO_T=' ';;
461    esac;;
462   *)
463    ECHO_N='-n';;
464   esac
504 – if expr a : '\(a\)' >/dev/null 2>&1 &&
505 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
506 –  as_expr=expr
507 – else
508 –  as_expr=false
509 – fi
465  
466   rm -f conf$$ conf$$.exe conf$$.file
467   if test -d conf$$.dir; then
# Line 536 | Line 491 | if mkdir -p . 2>/dev/null; then
491   rmdir conf$$.dir 2>/dev/null
492  
493   if mkdir -p . 2>/dev/null; then
494 <  as_mkdir_p=:
494 >  as_mkdir_p='mkdir -p "$as_dir"'
495   else
496    test -d ./-p && rmdir ./-p
497    as_mkdir_p=false
# Line 555 | Line 510 | else
510        if test -d "$1"; then
511          test -d "$1/.";
512        else
513 <        case $1 in
513 >        case $1 in #(
514          -*)set "./$1";;
515          esac;
516 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
516 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
517          ???[sx]*):;;*)false;;esac;fi
518      '\'' sh
519    '
# Line 572 | Line 527 | as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
527   as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
528  
529  
575 –
530   exec 7<&0 </dev/null 6>&1
531  
532   # Name of the host.
# Line 591 | Line 545 | MAKEFLAGS=
545   subdirs=
546   MFLAGS=
547   MAKEFLAGS=
594 – SHELL=${CONFIG_SHELL-/bin/sh}
548  
549   # Identity of this package.
550   PACKAGE_NAME='OOPSE'
# Line 599 | Line 552 | PACKAGE_BUGREPORT='gezelter@nd.edu'
552   PACKAGE_VERSION='4.0'
553   PACKAGE_STRING='OOPSE 4.0'
554   PACKAGE_BUGREPORT='gezelter@nd.edu'
555 + PACKAGE_URL=''
556  
557   ac_unique_file="src/applications/oopse/oopse.cpp"
558   ac_default_prefix="/usr/local"
# Line 638 | Line 592 | ac_includes_default="\
592   # include <unistd.h>
593   #endif"
594  
595 < ac_subst_vars='SHELL
596 < PATH_SEPARATOR
597 < PACKAGE_NAME
598 < PACKAGE_TARNAME
599 < PACKAGE_VERSION
600 < PACKAGE_STRING
601 < PACKAGE_BUGREPORT
602 < exec_prefix
603 < prefix
604 < program_transform_name
605 < bindir
606 < sbindir
607 < libexecdir
608 < datarootdir
609 < datadir
610 < sysconfdir
611 < sharedstatedir
612 < localstatedir
613 < includedir
614 < oldincludedir
615 < docdir
616 < infodir
617 < htmldir
618 < dvidir
619 < pdfdir
620 < psdir
621 < libdir
622 < localedir
623 < mandir
624 < DEFS
625 < ECHO_C
626 < ECHO_N
627 < ECHO_T
628 < LIBS
629 < build_alias
630 < host_alias
631 < target_alias
632 < build
633 < build_cpu
634 < build_vendor
635 < build_os
636 < host
637 < host_cpu
638 < host_vendor
639 < host_os
640 < PROGNAME
641 < debug
642 < USE_SINGLE_PRECISION
643 < ac_cc_set
644 < ac_cc_path
645 < ac_cxx_set
646 < ac_cxx_path
647 < ac_fc_set
648 < ac_fc_path
649 < acx_mpi_mpicc
650 < acx_mpi_mpicc_path
651 < acx_mpi_mpif90
652 < acx_mpi_mpif90_path
653 < acx_mpi_mpicxx
700 < acx_mpi_mpicxx_path
701 < MPI_CPPFLAGS
702 < MPI_LIBS
703 < MPI90_LIBS
595 > ac_subst_vars='LTLIBOBJS
596 > SUBDIRS
597 > OOPSE_HOME
598 > OOPSE
599 > MKINSTALLDIRS
600 > BATEXT
601 > enable_latex_docs
602 > enable_html_docs
603 > enable_dot
604 > DOC
605 > DOT
606 > DOXYGEN
607 > USE_CGAL
608 > CGAL_LIBS
609 > CGAL_LDFLAGS
610 > CGAL_CPPFLAGS
611 > CGAL_CXXFLAGS
612 > CGAL_MAKEFILE
613 > POW_LIB
614 > LIBOBJS
615 > USE_OPENBABEL
616 > OPENBABEL_LIB
617 > OPENBABEL_LIB_DIR
618 > OPENBABEL_INC_DIR
619 > CXXCPP
620 > USE_QHULL
621 > QHULL
622 > QHULL_LIB_DIR
623 > QHULL_INC_DIR
624 > FFTW_LIBS
625 > FFTW_LIB_DIR
626 > FFTW_INC_DIR
627 > ZLIB
628 > ZLIB_LIB_DIR
629 > ZLIB_INC_DIR
630 > F90_MODULE_NAMES
631 > F90MODINCSPEC
632 > MODDIRFLAG
633 > F90_WORK_FILES_ARG
634 > MOD
635 > FC_FUNC_
636 > FC_FUNC
637 > FCLIBS
638 > PREPDEFFLAG
639 > FCFLAGS_SRCEXT
640 > FCFLAGS_F90
641 > PS
642 > AR
643 > INSTALL_DATA
644 > INSTALL_SCRIPT
645 > INSTALL_PROGRAM
646 > PERL_SHEBANG
647 > PERLINTERP
648 > RANLIB
649 > SET_MAKE
650 > LN_S
651 > EGREP
652 > GREP
653 > CPP
654   USE_MPI
655 < CXX
706 < CXXFLAGS
707 < LDFLAGS
708 < CPPFLAGS
709 < ac_ct_CXX
710 < EXEEXT
711 < OBJEXT
712 < CC
713 < CFLAGS
714 < ac_ct_CC
715 < FC
716 < FCFLAGS
655 > MPIFC
656   ac_ct_FC
657 < CPP
658 < GREP
659 < EGREP
660 < LN_S
661 < SET_MAKE
662 < RANLIB
663 < PERLINTERP
664 < PERL_SHEBANG
665 < INSTALL_PROGRAM
666 < INSTALL_SCRIPT
667 < INSTALL_DATA
668 < AR
669 < PS
670 < FCFLAGS_F90
671 < FCFLAGS_SRCEXT
672 < PREPDEFFLAG
673 < FCLIBS
674 < FC_FUNC
675 < FC_FUNC_
676 < MOD
677 < F90_WORK_FILES_ARG
678 < MODDIRFLAG
679 < F90MODINCSPEC
680 < F90_MODULE_NAMES
681 < ZLIB_INC_DIR
682 < ZLIB_LIB_DIR
683 < ZLIB
684 < FFTW_INC_DIR
685 < FFTW_LIB_DIR
686 < FFTW_LIBS
687 < QHULL_INC_DIR
688 < QHULL_LIB_DIR
689 < QHULL
690 < USE_QHULL
691 < CXXCPP
692 < OPENBABEL_INC_DIR
693 < OPENBABEL_LIB_DIR
694 < OPENBABEL_LIB
695 < USE_OPENBABEL
696 < LIBOBJS
697 < POW_LIB
698 < CGAL_MAKEFILE
699 < CGAL_CXXFLAGS
700 < CGAL_CPPFLAGS
701 < CGAL_LDFLAGS
702 < CGAL_LIBS
703 < USE_CGAL
704 < DOXYGEN
705 < DOT
706 < DOC
707 < enable_dot
708 < enable_html_docs
709 < enable_latex_docs
710 < BATEXT
711 < MKINSTALLDIRS
712 < OOPSE
713 < OOPSE_HOME
714 < SUBDIRS
715 < LTLIBOBJS'
657 > FCFLAGS
658 > FC
659 > MPICC
660 > ac_ct_CC
661 > CFLAGS
662 > CC
663 > MPILIBS
664 > MPICXX
665 > OBJEXT
666 > EXEEXT
667 > ac_ct_CXX
668 > CPPFLAGS
669 > LDFLAGS
670 > CXXFLAGS
671 > CXX
672 > ac_fc_path
673 > ac_fc_set
674 > ac_cxx_path
675 > ac_cxx_set
676 > ac_cc_path
677 > ac_cc_set
678 > USE_SINGLE_PRECISION
679 > debug
680 > PROGNAME
681 > host_os
682 > host_vendor
683 > host_cpu
684 > host
685 > build_os
686 > build_vendor
687 > build_cpu
688 > build
689 > target_alias
690 > host_alias
691 > build_alias
692 > LIBS
693 > ECHO_T
694 > ECHO_N
695 > ECHO_C
696 > DEFS
697 > mandir
698 > localedir
699 > libdir
700 > psdir
701 > pdfdir
702 > dvidir
703 > htmldir
704 > infodir
705 > docdir
706 > oldincludedir
707 > includedir
708 > localstatedir
709 > sharedstatedir
710 > sysconfdir
711 > datadir
712 > datarootdir
713 > libexecdir
714 > sbindir
715 > bindir
716 > program_transform_name
717 > prefix
718 > exec_prefix
719 > PACKAGE_URL
720 > PACKAGE_BUGREPORT
721 > PACKAGE_STRING
722 > PACKAGE_VERSION
723 > PACKAGE_TARNAME
724 > PACKAGE_NAME
725 > PATH_SEPARATOR
726 > SHELL'
727   ac_subst_files=''
728   ac_user_opts='
729   enable_option_checking
# Line 781 | Line 731 | enable_float
731   enable_debug
732   enable_single
733   enable_float
784 – with_mpi
734   with_perl_shebang
735   with_zlib
736   with_fftw
# Line 802 | Line 751 | CCC
751   LIBS
752   CPPFLAGS
753   CCC
754 + MPICXX
755   CC
756   CFLAGS
757 + MPICC
758   FC
759   FCFLAGS
760 + MPIFC
761   CPP
762   CXXCPP'
763  
# Line 916 | Line 868 | do
868      ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
869      # Reject names that are not valid shell variable names.
870      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
871 <      { $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
920 <   { (exit 1); exit 1; }; }
871 >      as_fn_error "invalid feature name: $ac_useropt"
872      ac_useropt_orig=$ac_useropt
873      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
874      case $ac_user_opts in
# Line 943 | Line 894 | do
894      ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
895      # Reject names that are not valid shell variable names.
896      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
897 <      { $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
947 <   { (exit 1); exit 1; }; }
897 >      as_fn_error "invalid feature name: $ac_useropt"
898      ac_useropt_orig=$ac_useropt
899      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
900      case $ac_user_opts in
# Line 1148 | Line 1098 | do
1098      ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1099      # Reject names that are not valid shell variable names.
1100      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1101 <      { $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1152 <   { (exit 1); exit 1; }; }
1101 >      as_fn_error "invalid package name: $ac_useropt"
1102      ac_useropt_orig=$ac_useropt
1103      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1104      case $ac_user_opts in
# Line 1165 | Line 1114 | do
1114      ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1115      # Reject names that are not valid shell variable names.
1116      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1117 <      { $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1169 <   { (exit 1); exit 1; }; }
1117 >      as_fn_error "invalid package name: $ac_useropt"
1118      ac_useropt_orig=$ac_useropt
1119      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1120      case $ac_user_opts in
# Line 1196 | Line 1144 | do
1144    | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1145      x_libraries=$ac_optarg ;;
1146  
1147 <  -*) { $as_echo "$as_me: error: unrecognized option: $ac_option
1148 < Try \`$0 --help' for more information." >&2
1201 <   { (exit 1); exit 1; }; }
1147 >  -*) as_fn_error "unrecognized option: \`$ac_option'
1148 > Try \`$0 --help' for more information."
1149      ;;
1150  
1151    *=*)
1152      ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1153      # Reject names that are not valid shell variable names.
1154 <    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
1155 <      { $as_echo "$as_me: error: invalid variable name: $ac_envvar" >&2
1156 <   { (exit 1); exit 1; }; }
1154 >    case $ac_envvar in #(
1155 >      '' | [0-9]* | *[!_$as_cr_alnum]* )
1156 >      as_fn_error "invalid variable name: \`$ac_envvar'" ;;
1157 >    esac
1158      eval $ac_envvar=\$ac_optarg
1159      export $ac_envvar ;;
1160  
# Line 1223 | Line 1171 | if test -n "$ac_prev"; then
1171  
1172   if test -n "$ac_prev"; then
1173    ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1174 <  { $as_echo "$as_me: error: missing argument to $ac_option" >&2
1227 <   { (exit 1); exit 1; }; }
1174 >  as_fn_error "missing argument to $ac_option"
1175   fi
1176  
1177   if test -n "$ac_unrecognized_opts"; then
1178    case $enable_option_checking in
1179      no) ;;
1180 <    fatal) { $as_echo "$as_me: error: Unrecognized options: $ac_unrecognized_opts" >&2
1181 <   { (exit 1); exit 1; }; } ;;
1235 <    *)     $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2 ;;
1180 >    fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;;
1181 >    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1182    esac
1183   fi
1184  
# Line 1254 | Line 1200 | do
1200      [\\/$]* | ?:[\\/]* )  continue;;
1201      NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1202    esac
1203 <  { $as_echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
1258 <   { (exit 1); exit 1; }; }
1203 >  as_fn_error "expected an absolute directory name for --$ac_var: $ac_val"
1204   done
1205  
1206   # There might be people who depend on the old broken behavior: `$host'
# Line 1285 | Line 1230 | ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1230   ac_pwd=`pwd` && test -n "$ac_pwd" &&
1231   ac_ls_di=`ls -di .` &&
1232   ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1233 <  { $as_echo "$as_me: error: Working directory cannot be determined" >&2
1289 <   { (exit 1); exit 1; }; }
1233 >  as_fn_error "working directory cannot be determined"
1234   test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1235 <  { $as_echo "$as_me: error: pwd does not report name of working directory" >&2
1292 <   { (exit 1); exit 1; }; }
1235 >  as_fn_error "pwd does not report name of working directory"
1236  
1237  
1238   # Find the source files, if location was not specified.
# Line 1328 | Line 1271 | if test ! -r "$srcdir/$ac_unique_file"; then
1271   fi
1272   if test ! -r "$srcdir/$ac_unique_file"; then
1273    test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1274 <  { $as_echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
1332 <   { (exit 1); exit 1; }; }
1274 >  as_fn_error "cannot find sources ($ac_unique_file) in $srcdir"
1275   fi
1276   ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1277   ac_abs_confdir=`(
1278 <        cd "$srcdir" && test -r "./$ac_unique_file" || { $as_echo "$as_me: error: $ac_msg" >&2
1337 <   { (exit 1); exit 1; }; }
1278 >        cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error "$ac_msg"
1279          pwd)`
1280   # When building in place, set srcdir=.
1281   if test "$ac_abs_confdir" = "$ac_pwd"; then
# Line 1445 | Line 1386 | Optional Packages:
1386   Optional Packages:
1387    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1388    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1448 –  --with-mpi=auto|mpich|lam|openmpi|no
1449 –                          Indicates which kind of MPI implementation to use
1450 –                          [default=auto]
1389    --with-perl-shebang     override what perl thinks is the way for the kernel
1390                            to start it (seldom needed)
1391    --with-zlib=DIR         root directory path of zlib installation (defaults
# Line 1470 | Line 1408 | Some influential environment variables:
1408    LIBS        libraries to pass to the linker, e.g. -l<library>
1409    CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1410                you have headers in a nonstandard directory <include dir>
1411 +  MPICXX      MPI C++ compiler command
1412    CC          C compiler command
1413    CFLAGS      C compiler flags
1414 +  MPICC       MPI C compiler command
1415    FC          Fortran compiler command
1416    FCFLAGS     Fortran compiler flags
1417 +  MPIFC       MPI Fortran compiler command
1418    CPP         C preprocessor
1419    CXXCPP      C++ preprocessor
1420  
# Line 1544 | Line 1485 | OOPSE configure 4.0
1485   if $ac_init_version; then
1486    cat <<\_ACEOF
1487   OOPSE configure 4.0
1488 < generated by GNU Autoconf 2.62
1488 > generated by GNU Autoconf 2.64
1489  
1490 < Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1550 < 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
1490 > Copyright (C) 2009 Free Software Foundation, Inc.
1491   This configure script is free software; the Free Software Foundation
1492   gives unlimited permission to copy, distribute and modify it.
1493   _ACEOF
1494    exit
1495   fi
1556 – cat >config.log <<_ACEOF
1557 – This file contains any messages produced by compilers while
1558 – running configure, to aid debugging if configure makes a mistake.
1496  
1497 < It was created by OOPSE $as_me 4.0, which was
1498 < generated by GNU Autoconf 2.62.  Invocation command line was
1497 > ## ------------------------ ##
1498 > ## Autoconf initialization. ##
1499 > ## ------------------------ ##
1500  
1501 <  $ $0 $@
1502 <
1503 < _ACEOF
1504 < exec 5>>config.log
1501 > # ac_fn_cxx_try_compile LINENO
1502 > # ----------------------------
1503 > # Try to compile conftest.$ac_ext, and return whether this succeeded.
1504 > ac_fn_cxx_try_compile ()
1505   {
1506 < cat <<_ASUNAME
1507 < ## --------- ##
1508 < ## Platform. ##
1509 < ## --------- ##
1510 <
1511 < hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1512 < uname -m = `(uname -m) 2>/dev/null || echo unknown`
1513 < uname -r = `(uname -r) 2>/dev/null || echo unknown`
1514 < uname -s = `(uname -s) 2>/dev/null || echo unknown`
1515 < uname -v = `(uname -v) 2>/dev/null || echo unknown`
1516 <
1517 < /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1518 < /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1506 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1507 >  rm -f conftest.$ac_objext
1508 >  if { { ac_try="$ac_compile"
1509 > case "(($ac_try" in
1510 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1511 >  *) ac_try_echo=$ac_try;;
1512 > esac
1513 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1514 > $as_echo "$ac_try_echo"; } >&5
1515 >  (eval "$ac_compile") 2>conftest.err
1516 >  ac_status=$?
1517 >  if test -s conftest.err; then
1518 >    grep -v '^ *+' conftest.err >conftest.er1
1519 >    cat conftest.er1 >&5
1520 >    mv -f conftest.er1 conftest.err
1521 >  fi
1522 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1523 >  test $ac_status = 0; } && {
1524 >         test -z "$ac_cxx_werror_flag" ||
1525 >         test ! -s conftest.err
1526 >       } && test -s conftest.$ac_objext; then :
1527 >  ac_retval=0
1528 > else
1529 >  $as_echo "$as_me: failed program was:" >&5
1530 > sed 's/^/| /' conftest.$ac_ext >&5
1531  
1532 < /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1533 < /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1534 < /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1535 < /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
1586 < /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1587 < /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1588 < /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1532 >        ac_retval=1
1533 > fi
1534 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1535 >  return $ac_retval
1536  
1537 < _ASUNAME
1537 > } # ac_fn_cxx_try_compile
1538  
1539 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1540 < for as_dir in $PATH
1541 < do
1542 <  IFS=$as_save_IFS
1543 <  test -z "$as_dir" && as_dir=.
1544 <  $as_echo "PATH: $as_dir"
1545 < done
1546 < IFS=$as_save_IFS
1547 <
1548 < } >&5
1549 <
1550 < cat >&5 <<_ACEOF
1551 <
1552 <
1553 < ## ----------- ##
1554 < ## Core tests. ##
1555 < ## ----------- ##
1556 <
1557 < _ACEOF
1558 <
1559 <
1560 < # Keep a trace of the command line.
1539 > # ac_fn_cxx_try_link LINENO
1540 > # -------------------------
1541 > # Try to link conftest.$ac_ext, and return whether this succeeded.
1542 > ac_fn_cxx_try_link ()
1543 > {
1544 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1545 >  rm -f conftest.$ac_objext conftest$ac_exeext
1546 >  if { { ac_try="$ac_link"
1547 > case "(($ac_try" in
1548 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1549 >  *) ac_try_echo=$ac_try;;
1550 > esac
1551 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1552 > $as_echo "$ac_try_echo"; } >&5
1553 >  (eval "$ac_link") 2>conftest.err
1554 >  ac_status=$?
1555 >  if test -s conftest.err; then
1556 >    grep -v '^ *+' conftest.err >conftest.er1
1557 >    cat conftest.er1 >&5
1558 >    mv -f conftest.er1 conftest.err
1559 >  fi
1560 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1561 >  test $ac_status = 0; } && {
1562 >         test -z "$ac_cxx_werror_flag" ||
1563 >         test ! -s conftest.err
1564 >       } && test -s conftest$ac_exeext && {
1565 >         test "$cross_compiling" = yes ||
1566 >         $as_test_x conftest$ac_exeext
1567 >       }; then :
1568 >  ac_retval=0
1569 > else
1570 >  $as_echo "$as_me: failed program was:" >&5
1571 > sed 's/^/| /' conftest.$ac_ext >&5
1572 >
1573 >        ac_retval=1
1574 > fi
1575 >  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1576 >  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1577 >  # interfere with the next link command; also delete a directory that is
1578 >  # left behind by Apple's compiler.  We do this before executing the actions.
1579 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1580 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1581 >  return $ac_retval
1582 >
1583 > } # ac_fn_cxx_try_link
1584 >
1585 > # ac_fn_cxx_check_func LINENO FUNC VAR
1586 > # ------------------------------------
1587 > # Tests whether FUNC exists, setting the cache variable VAR accordingly
1588 > ac_fn_cxx_check_func ()
1589 > {
1590 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1591 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1592 > $as_echo_n "checking for $2... " >&6; }
1593 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1594 >  $as_echo_n "(cached) " >&6
1595 > else
1596 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1597 > /* end confdefs.h.  */
1598 > /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1599 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1600 > #define $2 innocuous_$2
1601 >
1602 > /* System header to define __stub macros and hopefully few prototypes,
1603 >    which can conflict with char $2 (); below.
1604 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1605 >    <limits.h> exists even on freestanding compilers.  */
1606 >
1607 > #ifdef __STDC__
1608 > # include <limits.h>
1609 > #else
1610 > # include <assert.h>
1611 > #endif
1612 >
1613 > #undef $2
1614 >
1615 > /* Override any GCC internal prototype to avoid an error.
1616 >   Use char because int might match the return type of a GCC
1617 >   builtin and then its argument prototype would still apply.  */
1618 > #ifdef __cplusplus
1619 > extern "C"
1620 > #endif
1621 > char $2 ();
1622 > /* The GNU C library defines this for functions which it implements
1623 >    to always fail with ENOSYS.  Some functions are actually named
1624 >    something starting with __ and the normal name is an alias.  */
1625 > #if defined __stub_$2 || defined __stub___$2
1626 > choke me
1627 > #endif
1628 >
1629 > int
1630 > main ()
1631 > {
1632 > return $2 ();
1633 >  ;
1634 >  return 0;
1635 > }
1636 > _ACEOF
1637 > if ac_fn_cxx_try_link "$LINENO"; then :
1638 >  eval "$3=yes"
1639 > else
1640 >  eval "$3=no"
1641 > fi
1642 > rm -f core conftest.err conftest.$ac_objext \
1643 >    conftest$ac_exeext conftest.$ac_ext
1644 > fi
1645 > eval ac_res=\$$3
1646 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1647 > $as_echo "$ac_res" >&6; }
1648 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1649 >
1650 > } # ac_fn_cxx_check_func
1651 >
1652 > # ac_fn_c_try_compile LINENO
1653 > # --------------------------
1654 > # Try to compile conftest.$ac_ext, and return whether this succeeded.
1655 > ac_fn_c_try_compile ()
1656 > {
1657 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1658 >  rm -f conftest.$ac_objext
1659 >  if { { ac_try="$ac_compile"
1660 > case "(($ac_try" in
1661 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1662 >  *) ac_try_echo=$ac_try;;
1663 > esac
1664 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1665 > $as_echo "$ac_try_echo"; } >&5
1666 >  (eval "$ac_compile") 2>conftest.err
1667 >  ac_status=$?
1668 >  if test -s conftest.err; then
1669 >    grep -v '^ *+' conftest.err >conftest.er1
1670 >    cat conftest.er1 >&5
1671 >    mv -f conftest.er1 conftest.err
1672 >  fi
1673 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1674 >  test $ac_status = 0; } && {
1675 >         test -z "$ac_c_werror_flag" ||
1676 >         test ! -s conftest.err
1677 >       } && test -s conftest.$ac_objext; then :
1678 >  ac_retval=0
1679 > else
1680 >  $as_echo "$as_me: failed program was:" >&5
1681 > sed 's/^/| /' conftest.$ac_ext >&5
1682 >
1683 >        ac_retval=1
1684 > fi
1685 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1686 >  return $ac_retval
1687 >
1688 > } # ac_fn_c_try_compile
1689 >
1690 > # ac_fn_c_try_link LINENO
1691 > # -----------------------
1692 > # Try to link conftest.$ac_ext, and return whether this succeeded.
1693 > ac_fn_c_try_link ()
1694 > {
1695 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1696 >  rm -f conftest.$ac_objext conftest$ac_exeext
1697 >  if { { ac_try="$ac_link"
1698 > case "(($ac_try" in
1699 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1700 >  *) ac_try_echo=$ac_try;;
1701 > esac
1702 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1703 > $as_echo "$ac_try_echo"; } >&5
1704 >  (eval "$ac_link") 2>conftest.err
1705 >  ac_status=$?
1706 >  if test -s conftest.err; then
1707 >    grep -v '^ *+' conftest.err >conftest.er1
1708 >    cat conftest.er1 >&5
1709 >    mv -f conftest.er1 conftest.err
1710 >  fi
1711 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1712 >  test $ac_status = 0; } && {
1713 >         test -z "$ac_c_werror_flag" ||
1714 >         test ! -s conftest.err
1715 >       } && test -s conftest$ac_exeext && {
1716 >         test "$cross_compiling" = yes ||
1717 >         $as_test_x conftest$ac_exeext
1718 >       }; then :
1719 >  ac_retval=0
1720 > else
1721 >  $as_echo "$as_me: failed program was:" >&5
1722 > sed 's/^/| /' conftest.$ac_ext >&5
1723 >
1724 >        ac_retval=1
1725 > fi
1726 >  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1727 >  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1728 >  # interfere with the next link command; also delete a directory that is
1729 >  # left behind by Apple's compiler.  We do this before executing the actions.
1730 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1731 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1732 >  return $ac_retval
1733 >
1734 > } # ac_fn_c_try_link
1735 >
1736 > # ac_fn_c_check_func LINENO FUNC VAR
1737 > # ----------------------------------
1738 > # Tests whether FUNC exists, setting the cache variable VAR accordingly
1739 > ac_fn_c_check_func ()
1740 > {
1741 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1742 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1743 > $as_echo_n "checking for $2... " >&6; }
1744 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1745 >  $as_echo_n "(cached) " >&6
1746 > else
1747 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1748 > /* end confdefs.h.  */
1749 > /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1750 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1751 > #define $2 innocuous_$2
1752 >
1753 > /* System header to define __stub macros and hopefully few prototypes,
1754 >    which can conflict with char $2 (); below.
1755 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1756 >    <limits.h> exists even on freestanding compilers.  */
1757 >
1758 > #ifdef __STDC__
1759 > # include <limits.h>
1760 > #else
1761 > # include <assert.h>
1762 > #endif
1763 >
1764 > #undef $2
1765 >
1766 > /* Override any GCC internal prototype to avoid an error.
1767 >   Use char because int might match the return type of a GCC
1768 >   builtin and then its argument prototype would still apply.  */
1769 > #ifdef __cplusplus
1770 > extern "C"
1771 > #endif
1772 > char $2 ();
1773 > /* The GNU C library defines this for functions which it implements
1774 >    to always fail with ENOSYS.  Some functions are actually named
1775 >    something starting with __ and the normal name is an alias.  */
1776 > #if defined __stub_$2 || defined __stub___$2
1777 > choke me
1778 > #endif
1779 >
1780 > int
1781 > main ()
1782 > {
1783 > return $2 ();
1784 >  ;
1785 >  return 0;
1786 > }
1787 > _ACEOF
1788 > if ac_fn_c_try_link "$LINENO"; then :
1789 >  eval "$3=yes"
1790 > else
1791 >  eval "$3=no"
1792 > fi
1793 > rm -f core conftest.err conftest.$ac_objext \
1794 >    conftest$ac_exeext conftest.$ac_ext
1795 > fi
1796 > eval ac_res=\$$3
1797 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1798 > $as_echo "$ac_res" >&6; }
1799 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1800 >
1801 > } # ac_fn_c_check_func
1802 >
1803 > # ac_fn_fc_try_compile LINENO
1804 > # ---------------------------
1805 > # Try to compile conftest.$ac_ext, and return whether this succeeded.
1806 > ac_fn_fc_try_compile ()
1807 > {
1808 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1809 >  rm -f conftest.$ac_objext
1810 >  if { { ac_try="$ac_compile"
1811 > case "(($ac_try" in
1812 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1813 >  *) ac_try_echo=$ac_try;;
1814 > esac
1815 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1816 > $as_echo "$ac_try_echo"; } >&5
1817 >  (eval "$ac_compile") 2>conftest.err
1818 >  ac_status=$?
1819 >  if test -s conftest.err; then
1820 >    grep -v '^ *+' conftest.err >conftest.er1
1821 >    cat conftest.er1 >&5
1822 >    mv -f conftest.er1 conftest.err
1823 >  fi
1824 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1825 >  test $ac_status = 0; } && {
1826 >         test -z "$ac_fc_werror_flag" ||
1827 >         test ! -s conftest.err
1828 >       } && test -s conftest.$ac_objext; then :
1829 >  ac_retval=0
1830 > else
1831 >  $as_echo "$as_me: failed program was:" >&5
1832 > sed 's/^/| /' conftest.$ac_ext >&5
1833 >
1834 >        ac_retval=1
1835 > fi
1836 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1837 >  return $ac_retval
1838 >
1839 > } # ac_fn_fc_try_compile
1840 >
1841 > # ac_fn_fc_try_link LINENO
1842 > # ------------------------
1843 > # Try to link conftest.$ac_ext, and return whether this succeeded.
1844 > ac_fn_fc_try_link ()
1845 > {
1846 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1847 >  rm -f conftest.$ac_objext conftest$ac_exeext
1848 >  if { { ac_try="$ac_link"
1849 > case "(($ac_try" in
1850 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1851 >  *) ac_try_echo=$ac_try;;
1852 > esac
1853 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1854 > $as_echo "$ac_try_echo"; } >&5
1855 >  (eval "$ac_link") 2>conftest.err
1856 >  ac_status=$?
1857 >  if test -s conftest.err; then
1858 >    grep -v '^ *+' conftest.err >conftest.er1
1859 >    cat conftest.er1 >&5
1860 >    mv -f conftest.er1 conftest.err
1861 >  fi
1862 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1863 >  test $ac_status = 0; } && {
1864 >         test -z "$ac_fc_werror_flag" ||
1865 >         test ! -s conftest.err
1866 >       } && test -s conftest$ac_exeext && {
1867 >         test "$cross_compiling" = yes ||
1868 >         $as_test_x conftest$ac_exeext
1869 >       }; then :
1870 >  ac_retval=0
1871 > else
1872 >  $as_echo "$as_me: failed program was:" >&5
1873 > sed 's/^/| /' conftest.$ac_ext >&5
1874 >
1875 >        ac_retval=1
1876 > fi
1877 >  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1878 >  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1879 >  # interfere with the next link command; also delete a directory that is
1880 >  # left behind by Apple's compiler.  We do this before executing the actions.
1881 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1882 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1883 >  return $ac_retval
1884 >
1885 > } # ac_fn_fc_try_link
1886 >
1887 > # ac_fn_c_try_cpp LINENO
1888 > # ----------------------
1889 > # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1890 > ac_fn_c_try_cpp ()
1891 > {
1892 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1893 >  if { { ac_try="$ac_cpp conftest.$ac_ext"
1894 > case "(($ac_try" in
1895 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1896 >  *) ac_try_echo=$ac_try;;
1897 > esac
1898 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1899 > $as_echo "$ac_try_echo"; } >&5
1900 >  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1901 >  ac_status=$?
1902 >  if test -s conftest.err; then
1903 >    grep -v '^ *+' conftest.err >conftest.er1
1904 >    cat conftest.er1 >&5
1905 >    mv -f conftest.er1 conftest.err
1906 >  fi
1907 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1908 >  test $ac_status = 0; } >/dev/null && {
1909 >         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
1910 >         test ! -s conftest.err
1911 >       }; then :
1912 >  ac_retval=0
1913 > else
1914 >  $as_echo "$as_me: failed program was:" >&5
1915 > sed 's/^/| /' conftest.$ac_ext >&5
1916 >
1917 >    ac_retval=1
1918 > fi
1919 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
1920 >  return $ac_retval
1921 >
1922 > } # ac_fn_c_try_cpp
1923 >
1924 > # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1925 > # -------------------------------------------------------
1926 > # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1927 > # the include files in INCLUDES and setting the cache variable VAR
1928 > # accordingly.
1929 > ac_fn_c_check_header_mongrel ()
1930 > {
1931 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1932 >  if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1933 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1934 > $as_echo_n "checking for $2... " >&6; }
1935 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
1936 >  $as_echo_n "(cached) " >&6
1937 > fi
1938 > eval ac_res=\$$3
1939 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1940 > $as_echo "$ac_res" >&6; }
1941 > else
1942 >  # Is the header compilable?
1943 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1944 > $as_echo_n "checking $2 usability... " >&6; }
1945 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1946 > /* end confdefs.h.  */
1947 > $4
1948 > #include <$2>
1949 > _ACEOF
1950 > if ac_fn_c_try_compile "$LINENO"; then :
1951 >  ac_header_compiler=yes
1952 > else
1953 >  ac_header_compiler=no
1954 > fi
1955 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1956 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1957 > $as_echo "$ac_header_compiler" >&6; }
1958 >
1959 > # Is the header present?
1960 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1961 > $as_echo_n "checking $2 presence... " >&6; }
1962 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1963 > /* end confdefs.h.  */
1964 > #include <$2>
1965 > _ACEOF
1966 > if ac_fn_c_try_cpp "$LINENO"; then :
1967 >  ac_header_preproc=yes
1968 > else
1969 >  ac_header_preproc=no
1970 > fi
1971 > rm -f conftest.err conftest.$ac_ext
1972 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1973 > $as_echo "$ac_header_preproc" >&6; }
1974 >
1975 > # So?  What about this header?
1976 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1977 >  yes:no: )
1978 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1979 > $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1980 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1981 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1982 >    ;;
1983 >  no:yes:* )
1984 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1985 > $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1986 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1987 > $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1988 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1989 > $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1990 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1991 > $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1992 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1993 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1994 > ( cat <<\_ASBOX
1995 > ## ------------------------------ ##
1996 > ## Report this to gezelter@nd.edu ##
1997 > ## ------------------------------ ##
1998 > _ASBOX
1999 >     ) | sed "s/^/$as_me: WARNING:     /" >&2
2000 >    ;;
2001 > esac
2002 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2003 > $as_echo_n "checking for $2... " >&6; }
2004 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2005 >  $as_echo_n "(cached) " >&6
2006 > else
2007 >  eval "$3=\$ac_header_compiler"
2008 > fi
2009 > eval ac_res=\$$3
2010 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2011 > $as_echo "$ac_res" >&6; }
2012 > fi
2013 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2014 >
2015 > } # ac_fn_c_check_header_mongrel
2016 >
2017 > # ac_fn_c_try_run LINENO
2018 > # ----------------------
2019 > # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
2020 > # that executables *can* be run.
2021 > ac_fn_c_try_run ()
2022 > {
2023 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2024 >  if { { ac_try="$ac_link"
2025 > case "(($ac_try" in
2026 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2027 >  *) ac_try_echo=$ac_try;;
2028 > esac
2029 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2030 > $as_echo "$ac_try_echo"; } >&5
2031 >  (eval "$ac_link") 2>&5
2032 >  ac_status=$?
2033 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2034 >  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
2035 >  { { case "(($ac_try" in
2036 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2037 >  *) ac_try_echo=$ac_try;;
2038 > esac
2039 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2040 > $as_echo "$ac_try_echo"; } >&5
2041 >  (eval "$ac_try") 2>&5
2042 >  ac_status=$?
2043 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2044 >  test $ac_status = 0; }; }; then :
2045 >  ac_retval=0
2046 > else
2047 >  $as_echo "$as_me: program exited with status $ac_status" >&5
2048 >       $as_echo "$as_me: failed program was:" >&5
2049 > sed 's/^/| /' conftest.$ac_ext >&5
2050 >
2051 >       ac_retval=$ac_status
2052 > fi
2053 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
2054 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2055 >  return $ac_retval
2056 >
2057 > } # ac_fn_c_try_run
2058 >
2059 > # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
2060 > # -------------------------------------------------------
2061 > # Tests whether HEADER exists and can be compiled using the include files in
2062 > # INCLUDES, setting the cache variable VAR accordingly.
2063 > ac_fn_c_check_header_compile ()
2064 > {
2065 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2066 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2067 > $as_echo_n "checking for $2... " >&6; }
2068 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2069 >  $as_echo_n "(cached) " >&6
2070 > else
2071 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2072 > /* end confdefs.h.  */
2073 > $4
2074 > #include <$2>
2075 > _ACEOF
2076 > if ac_fn_c_try_compile "$LINENO"; then :
2077 >  eval "$3=yes"
2078 > else
2079 >  eval "$3=no"
2080 > fi
2081 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2082 > fi
2083 > eval ac_res=\$$3
2084 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2085 > $as_echo "$ac_res" >&6; }
2086 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2087 >
2088 > } # ac_fn_c_check_header_compile
2089 >
2090 > # ac_fn_cxx_try_cpp LINENO
2091 > # ------------------------
2092 > # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
2093 > ac_fn_cxx_try_cpp ()
2094 > {
2095 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2096 >  if { { ac_try="$ac_cpp conftest.$ac_ext"
2097 > case "(($ac_try" in
2098 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2099 >  *) ac_try_echo=$ac_try;;
2100 > esac
2101 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
2102 > $as_echo "$ac_try_echo"; } >&5
2103 >  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
2104 >  ac_status=$?
2105 >  if test -s conftest.err; then
2106 >    grep -v '^ *+' conftest.err >conftest.er1
2107 >    cat conftest.er1 >&5
2108 >    mv -f conftest.er1 conftest.err
2109 >  fi
2110 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2111 >  test $ac_status = 0; } >/dev/null && {
2112 >         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2113 >         test ! -s conftest.err
2114 >       }; then :
2115 >  ac_retval=0
2116 > else
2117 >  $as_echo "$as_me: failed program was:" >&5
2118 > sed 's/^/| /' conftest.$ac_ext >&5
2119 >
2120 >    ac_retval=1
2121 > fi
2122 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2123 >  return $ac_retval
2124 >
2125 > } # ac_fn_cxx_try_cpp
2126 >
2127 > # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2128 > # ---------------------------------------------------------
2129 > # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2130 > # the include files in INCLUDES and setting the cache variable VAR
2131 > # accordingly.
2132 > ac_fn_cxx_check_header_mongrel ()
2133 > {
2134 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2135 >  if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2136 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2137 > $as_echo_n "checking for $2... " >&6; }
2138 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2139 >  $as_echo_n "(cached) " >&6
2140 > fi
2141 > eval ac_res=\$$3
2142 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2143 > $as_echo "$ac_res" >&6; }
2144 > else
2145 >  # Is the header compilable?
2146 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2147 > $as_echo_n "checking $2 usability... " >&6; }
2148 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2149 > /* end confdefs.h.  */
2150 > $4
2151 > #include <$2>
2152 > _ACEOF
2153 > if ac_fn_cxx_try_compile "$LINENO"; then :
2154 >  ac_header_compiler=yes
2155 > else
2156 >  ac_header_compiler=no
2157 > fi
2158 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2159 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2160 > $as_echo "$ac_header_compiler" >&6; }
2161 >
2162 > # Is the header present?
2163 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2164 > $as_echo_n "checking $2 presence... " >&6; }
2165 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2166 > /* end confdefs.h.  */
2167 > #include <$2>
2168 > _ACEOF
2169 > if ac_fn_cxx_try_cpp "$LINENO"; then :
2170 >  ac_header_preproc=yes
2171 > else
2172 >  ac_header_preproc=no
2173 > fi
2174 > rm -f conftest.err conftest.$ac_ext
2175 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2176 > $as_echo "$ac_header_preproc" >&6; }
2177 >
2178 > # So?  What about this header?
2179 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2180 >  yes:no: )
2181 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2182 > $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2183 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2184 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2185 >    ;;
2186 >  no:yes:* )
2187 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2188 > $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2189 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2190 > $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2191 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2192 > $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2193 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2194 > $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2195 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2196 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2197 > ( cat <<\_ASBOX
2198 > ## ------------------------------ ##
2199 > ## Report this to gezelter@nd.edu ##
2200 > ## ------------------------------ ##
2201 > _ASBOX
2202 >     ) | sed "s/^/$as_me: WARNING:     /" >&2
2203 >    ;;
2204 > esac
2205 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2206 > $as_echo_n "checking for $2... " >&6; }
2207 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2208 >  $as_echo_n "(cached) " >&6
2209 > else
2210 >  eval "$3=\$ac_header_compiler"
2211 > fi
2212 > eval ac_res=\$$3
2213 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2214 > $as_echo "$ac_res" >&6; }
2215 > fi
2216 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2217 >
2218 > } # ac_fn_cxx_check_header_mongrel
2219 >
2220 > # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
2221 > # -------------------------------------------
2222 > # Tests whether TYPE exists after having included INCLUDES, setting cache
2223 > # variable VAR accordingly.
2224 > ac_fn_c_check_type ()
2225 > {
2226 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2227 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2228 > $as_echo_n "checking for $2... " >&6; }
2229 > if { as_var=$3; eval "test \"\${$as_var+set}\" = set"; }; then :
2230 >  $as_echo_n "(cached) " >&6
2231 > else
2232 >  eval "$3=no"
2233 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2234 > /* end confdefs.h.  */
2235 > $4
2236 > #ifdef FC_DUMMY_MAIN
2237 > #ifndef FC_DUMMY_MAIN_EQ_F77
2238 > #  ifdef __cplusplus
2239 >     extern "C"
2240 > #  endif
2241 >   int FC_DUMMY_MAIN() { return 1; }
2242 > #endif
2243 > #endif
2244 > int
2245 > main ()
2246 > {
2247 > if (sizeof ($2))
2248 >         return 0;
2249 >  ;
2250 >  return 0;
2251 > }
2252 > _ACEOF
2253 > if ac_fn_c_try_compile "$LINENO"; then :
2254 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2255 > /* end confdefs.h.  */
2256 > $4
2257 > #ifdef FC_DUMMY_MAIN
2258 > #ifndef FC_DUMMY_MAIN_EQ_F77
2259 > #  ifdef __cplusplus
2260 >     extern "C"
2261 > #  endif
2262 >   int FC_DUMMY_MAIN() { return 1; }
2263 > #endif
2264 > #endif
2265 > int
2266 > main ()
2267 > {
2268 > if (sizeof (($2)))
2269 >            return 0;
2270 >  ;
2271 >  return 0;
2272 > }
2273 > _ACEOF
2274 > if ac_fn_c_try_compile "$LINENO"; then :
2275 >
2276 > else
2277 >  eval "$3=yes"
2278 > fi
2279 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2280 > fi
2281 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2282 > fi
2283 > eval ac_res=\$$3
2284 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2285 > $as_echo "$ac_res" >&6; }
2286 >  eval $as_lineno_stack; test "x$as_lineno_stack" = x && { as_lineno=; unset as_lineno;}
2287 >
2288 > } # ac_fn_c_check_type
2289 > cat >config.log <<_ACEOF
2290 > This file contains any messages produced by compilers while
2291 > running configure, to aid debugging if configure makes a mistake.
2292 >
2293 > It was created by OOPSE $as_me 4.0, which was
2294 > generated by GNU Autoconf 2.64.  Invocation command line was
2295 >
2296 >  $ $0 $@
2297 >
2298 > _ACEOF
2299 > exec 5>>config.log
2300 > {
2301 > cat <<_ASUNAME
2302 > ## --------- ##
2303 > ## Platform. ##
2304 > ## --------- ##
2305 >
2306 > hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2307 > uname -m = `(uname -m) 2>/dev/null || echo unknown`
2308 > uname -r = `(uname -r) 2>/dev/null || echo unknown`
2309 > uname -s = `(uname -s) 2>/dev/null || echo unknown`
2310 > uname -v = `(uname -v) 2>/dev/null || echo unknown`
2311 >
2312 > /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2313 > /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2314 >
2315 > /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
2316 > /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
2317 > /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
2318 > /usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
2319 > /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
2320 > /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
2321 > /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
2322 >
2323 > _ASUNAME
2324 >
2325 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2326 > for as_dir in $PATH
2327 > do
2328 >  IFS=$as_save_IFS
2329 >  test -z "$as_dir" && as_dir=.
2330 >    $as_echo "PATH: $as_dir"
2331 >  done
2332 > IFS=$as_save_IFS
2333 >
2334 > } >&5
2335 >
2336 > cat >&5 <<_ACEOF
2337 >
2338 >
2339 > ## ----------- ##
2340 > ## Core tests. ##
2341 > ## ----------- ##
2342 >
2343 > _ACEOF
2344 >
2345 >
2346 > # Keep a trace of the command line.
2347   # Strip out --no-create and --no-recursion so they do not pile up.
2348   # Strip out --silent because we don't want to record it for future runs.
2349   # Also quote any args containing shell meta-characters.
# Line 1632 | Line 2365 | do
2365        ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2366      esac
2367      case $ac_pass in
2368 <    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
2368 >    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2369      2)
2370 <      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
2370 >      as_fn_append ac_configure_args1 " '$ac_arg'"
2371        if test $ac_must_keep_next = true; then
2372          ac_must_keep_next=false # Got value, back to normal.
2373        else
# Line 1650 | Line 2383 | do
2383            -* ) ac_must_keep_next=true ;;
2384          esac
2385        fi
2386 <      ac_configure_args="$ac_configure_args '$ac_arg'"
2386 >      as_fn_append ac_configure_args " '$ac_arg'"
2387        ;;
2388      esac
2389    done
2390   done
2391 < $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
2392 < $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
2391 > { ac_configure_args0=; unset ac_configure_args0;}
2392 > { ac_configure_args1=; unset ac_configure_args1;}
2393  
2394   # When interrupted or exit'd, cleanup temporary files, and complete
2395   # config.log.  We remove comments because anyway the quotes in there
# Line 1681 | Line 2414 | _ASBOX
2414      case $ac_val in #(
2415      *${as_nl}*)
2416        case $ac_var in #(
2417 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
2418 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
2417 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2418 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2419        esac
2420        case $ac_var in #(
2421        _ | IFS | as_nl) ;; #(
2422        BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2423 <      *) $as_unset $ac_var ;;
2423 >      *) { eval $ac_var=; unset $ac_var;} ;;
2424        esac ;;
2425      esac
2426    done
# Line 1759 | Line 2492 | for ac_signal in 1 2 13 15; do
2492      exit $exit_status
2493   ' 0
2494   for ac_signal in 1 2 13 15; do
2495 <  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
2495 >  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2496   done
2497   ac_signal=0
2498  
2499   # confdefs.h avoids OS command line length limits that DEFS can exceed.
2500   rm -f -r conftest* confdefs.h
2501  
2502 + $as_echo "/* confdefs.h */" > confdefs.h
2503 +
2504   # Predefined preprocessor variables.
2505  
2506   cat >>confdefs.h <<_ACEOF
2507   #define PACKAGE_NAME "$PACKAGE_NAME"
2508   _ACEOF
2509  
1775 –
2510   cat >>confdefs.h <<_ACEOF
2511   #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
2512   _ACEOF
2513  
1780 –
2514   cat >>confdefs.h <<_ACEOF
2515   #define PACKAGE_VERSION "$PACKAGE_VERSION"
2516   _ACEOF
2517  
1785 –
2518   cat >>confdefs.h <<_ACEOF
2519   #define PACKAGE_STRING "$PACKAGE_STRING"
2520   _ACEOF
2521  
1790 –
2522   cat >>confdefs.h <<_ACEOF
2523   #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
2524   _ACEOF
2525  
2526 + cat >>confdefs.h <<_ACEOF
2527 + #define PACKAGE_URL "$PACKAGE_URL"
2528 + _ACEOF
2529  
2530 +
2531   # Let the site file select an alternate cache file if it wants to.
2532   # Prefer an explicitly selected file to automatically selected ones.
2533   ac_site_file1=NONE
# Line 1810 | Line 2545 | do
2545   do
2546    test "x$ac_site_file" = xNONE && continue
2547    if test -r "$ac_site_file"; then
2548 <    { $as_echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
2548 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2549   $as_echo "$as_me: loading site script $ac_site_file" >&6;}
2550      sed 's/^/| /' "$ac_site_file" >&5
2551      . "$ac_site_file"
# Line 1821 | Line 2556 | if test -r "$cache_file"; then
2556    # Some versions of bash will fail to source /dev/null (special
2557    # files actually), so we avoid doing that.
2558    if test -f "$cache_file"; then
2559 <    { $as_echo "$as_me:$LINENO: loading cache $cache_file" >&5
2559 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2560   $as_echo "$as_me: loading cache $cache_file" >&6;}
2561      case $cache_file in
2562        [\\/]* | ?:[\\/]* ) . "$cache_file";;
# Line 1829 | Line 2564 | else
2564      esac
2565    fi
2566   else
2567 <  { $as_echo "$as_me:$LINENO: creating cache $cache_file" >&5
2567 >  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
2568   $as_echo "$as_me: creating cache $cache_file" >&6;}
2569    >$cache_file
2570   fi
# Line 1844 | Line 2579 | for ac_var in $ac_precious_vars; do
2579    eval ac_new_val=\$ac_env_${ac_var}_value
2580    case $ac_old_set,$ac_new_set in
2581      set,)
2582 <      { $as_echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2582 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2583   $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2584        ac_cache_corrupted=: ;;
2585      ,set)
2586 <      { $as_echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
2586 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
2587   $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2588        ac_cache_corrupted=: ;;
2589      ,);;
# Line 1858 | Line 2593 | $as_echo "$as_me: error: \`$ac_var' was not set in the
2593          ac_old_val_w=`echo x $ac_old_val`
2594          ac_new_val_w=`echo x $ac_new_val`
2595          if test "$ac_old_val_w" != "$ac_new_val_w"; then
2596 <          { $as_echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
2596 >          { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
2597   $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2598            ac_cache_corrupted=:
2599          else
2600 <          { $as_echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2600 >          { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2601   $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
2602            eval $ac_var=\$ac_old_val
2603          fi
2604 <        { $as_echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
2604 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
2605   $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
2606 <        { $as_echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
2606 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
2607   $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
2608        fi;;
2609    esac
# Line 1880 | Line 2615 | $as_echo "$as_me:   current value: \`$ac_new_val'" >&2
2615      esac
2616      case " $ac_configure_args " in
2617        *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
2618 <      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
2618 >      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
2619      esac
2620    fi
2621   done
2622   if $ac_cache_corrupted; then
2623 <  { $as_echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
2623 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2624 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2625 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
2626   $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2627 <  { { $as_echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1891 < $as_echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1892 <   { (exit 1); exit 1; }; }
2627 >  as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
2628   fi
2629 + ## -------------------- ##
2630 + ## Main body of script. ##
2631 + ## -------------------- ##
2632  
1895 –
1896 –
1897 –
1898 –
1899 –
1900 –
1901 –
1902 –
1903 –
1904 –
1905 –
1906 –
1907 –
1908 –
1909 –
1910 –
1911 –
1912 –
1913 –
1914 –
1915 –
1916 –
1917 –
1918 –
2633   ac_ext=c
2634   ac_cpp='$CPP $CPPFLAGS'
2635   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 1925 | Line 2639 | for ac_dir in ac-tools "$srcdir"/ac-tools; do
2639  
2640   ac_aux_dir=
2641   for ac_dir in ac-tools "$srcdir"/ac-tools; do
2642 <  if test -f "$ac_dir/install-sh"; then
2643 <    ac_aux_dir=$ac_dir
2644 <    ac_install_sh="$ac_aux_dir/install-sh -c"
2645 <    break
2646 <  elif test -f "$ac_dir/install.sh"; then
2647 <    ac_aux_dir=$ac_dir
2648 <    ac_install_sh="$ac_aux_dir/install.sh -c"
1935 <    break
1936 <  elif test -f "$ac_dir/shtool"; then
1937 <    ac_aux_dir=$ac_dir
1938 <    ac_install_sh="$ac_aux_dir/shtool install -c"
1939 <    break
1940 <  fi
2642 >  for ac_t in install-sh install.sh shtool; do
2643 >    if test -f "$ac_dir/$ac_t"; then
2644 >      ac_aux_dir=$ac_dir
2645 >      ac_install_sh="$ac_aux_dir/$ac_t -c"
2646 >      break 2
2647 >    fi
2648 >  done
2649   done
2650   if test -z "$ac_aux_dir"; then
2651 <  { { $as_echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&5
1944 < $as_echo "$as_me: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&2;}
1945 <   { (exit 1); exit 1; }; }
2651 >  as_fn_error "cannot find install-sh, install.sh, or shtool in ac-tools \"$srcdir\"/ac-tools" "$LINENO" 5
2652   fi
2653  
2654   # These three variables are undocumented and unsupported,
# Line 2106 | Line 2812 | ac_config_headers="$ac_config_headers src/config.h"
2812  
2813  
2814  
2815 < # ACX_MPI_GET_PROG
2816 <
2817 < # ACX_DETECT_MPI_IMPLEMENTATION
2818 <
2819 <
2815 > # ===========================================================================
2816 > #             http://www.nongnu.org/autoconf-archive/ax_mpi.html
2817 > # ===========================================================================
2818 > #
2819 > # SYNOPSIS
2820 > #
2821 > #   AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
2822 > #
2823 > # DESCRIPTION
2824 > #
2825 > #   This macro tries to find out how to compile programs that use MPI
2826 > #   (Message Passing Interface), a standard API for parallel process
2827 > #   communication (see http://www-unix.mcs.anl.gov/mpi/)
2828 > #
2829 > #   On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
2830 > #   to the name of the MPI compiler, depending upon the current language.
2831 > #   (This may just be $CC/$CXX/$F77/$FC, but is more often something like
2832 > #   mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
2833 > #   are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
2834 > #   MPICC/MPICXX/MPIF77/MPIFC was not found).
2835 > #
2836 > #   If you want to compile everything with MPI, you should set:
2837 > #
2838 > #       CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
2839 > #       LIBS="$MPILIBS $LIBS"
2840 > #
2841 > #   NOTE: The above assumes that you will use $CC (or whatever) for linking
2842 > #   as well as for compiling. (This is the default for automake and most
2843 > #   Makefiles.)
2844 > #
2845 > #   The user can force a particular library/compiler by setting the
2846 > #   MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
2847 > #
2848 > #   ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
2849 > #   found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
2850 > #   found. If ACTION-IF-FOUND is not specified, the default action will
2851 > #   define HAVE_MPI.
2852 > #
2853 > # LICENSE
2854 > #
2855 > #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2856 > #   Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
2857 > #
2858 > #   This program is free software: you can redistribute it and/or modify it
2859 > #   under the terms of the GNU General Public License as published by the
2860 > #   Free Software Foundation, either version 3 of the License, or (at your
2861 > #   option) any later version.
2862 > #
2863 > #   This program is distributed in the hope that it will be useful, but
2864 > #   WITHOUT ANY WARRANTY; without even the implied warranty of
2865 > #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2866 > #   Public License for more details.
2867 > #
2868 > #   You should have received a copy of the GNU General Public License along
2869 > #   with this program. If not, see <http://www.gnu.org/licenses/>.
2870 > #
2871 > #   As a special exception, the respective Autoconf Macro's copyright owner
2872 > #   gives unlimited permission to copy, distribute and modify the configure
2873 > #   scripts that are the output of Autoconf when processing the Macro. You
2874 > #   need not follow the terms of the GNU General Public License when using
2875 > #   or distributing such scripts, even though portions of the text of the
2876 > #   Macro appear in them. The GNU General Public License (GPL) does govern
2877 > #   all other use of the material that constitutes the Autoconf Macro.
2878 > #
2879 > #   This special exception to the GPL applies to versions of the Autoconf
2880 > #   Macro released by the Autoconf Archive. When you make and distribute a
2881 > #   modified version of the Autoconf Macro, you may extend this special
2882 > #   exception to the GPL to apply to your modified version as well.
2883  
2884 + # This is what autoupdate's m4 run will expand.  It fires
2885 + # the warning (with _au_warn_XXX), outputs it into the
2886 + # updated configure.ac (with AC_DIAGNOSE), and then outputs
2887 + # the replacement expansion.
2888  
2889  
2890 < # ACX_MPI
2890 > # This is an auxiliary macro that is also run when
2891 > # autoupdate runs m4.  It simply calls m4_warning, but
2892 > # we need a wrapper so that each warning is emitted only
2893 > # once.  We break the quoting in m4_warning's argument in
2894 > # order to expand this macro's arguments, not AU_DEFUN's.
2895  
2896  
2897 + # Finally, this is the expansion that is picked up by
2898 + # autoconf.  It tells the user to run autoupdate, and
2899 + # then outputs the replacement expansion.  We do not care
2900 + # about autoupdate's warning because that contains
2901 + # information on what to do *after* running autoupdate.
2902  
2903  
2904  
# Line 2141 | Line 2923 | ac_config_headers="$ac_config_headers src/config.h"
2923  
2924  
2925  
2144 –
2926   # This is taken from http://autoqt.sourceforge.net/
2927   # Copyright (c) 2002, Geoffrey Wossum
2928   # All rights reserved.
# Line 2182 | Line 2963 | $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 |
2963   # who am i
2964   # Make sure we can run config.sub.
2965   $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
2966 <  { { $as_echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
2186 < $as_echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
2187 <   { (exit 1); exit 1; }; }
2966 >  as_fn_error "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2967  
2968 < { $as_echo "$as_me:$LINENO: checking build system type" >&5
2968 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2969   $as_echo_n "checking build system type... " >&6; }
2970 < if test "${ac_cv_build+set}" = set; then
2970 > if test "${ac_cv_build+set}" = set; then :
2971    $as_echo_n "(cached) " >&6
2972   else
2973    ac_build_alias=$build_alias
2974   test "x$ac_build_alias" = x &&
2975    ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2976   test "x$ac_build_alias" = x &&
2977 <  { { $as_echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
2199 < $as_echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
2200 <   { (exit 1); exit 1; }; }
2977 >  as_fn_error "cannot guess build type; you must specify one" "$LINENO" 5
2978   ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
2979 <  { { $as_echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
2203 < $as_echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
2204 <   { (exit 1); exit 1; }; }
2979 >  as_fn_error "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2980  
2981   fi
2982 < { $as_echo "$as_me:$LINENO: result: $ac_cv_build" >&5
2982 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2983   $as_echo "$ac_cv_build" >&6; }
2984   case $ac_cv_build in
2985   *-*-*) ;;
2986 < *) { { $as_echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
2212 < $as_echo "$as_me: error: invalid value of canonical build" >&2;}
2213 <   { (exit 1); exit 1; }; };;
2986 > *) as_fn_error "invalid value of canonical build" "$LINENO" 5;;
2987   esac
2988   build=$ac_cv_build
2989   ac_save_IFS=$IFS; IFS='-'
# Line 2226 | Line 2999 | case $build_os in *\ *) build_os=`echo "$build_os" | s
2999   case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
3000  
3001  
3002 < { $as_echo "$as_me:$LINENO: checking host system type" >&5
3002 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
3003   $as_echo_n "checking host system type... " >&6; }
3004 < if test "${ac_cv_host+set}" = set; then
3004 > if test "${ac_cv_host+set}" = set; then :
3005    $as_echo_n "(cached) " >&6
3006   else
3007    if test "x$host_alias" = x; then
3008    ac_cv_host=$ac_cv_build
3009   else
3010    ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
3011 <    { { $as_echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
2239 < $as_echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
2240 <   { (exit 1); exit 1; }; }
3011 >    as_fn_error "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
3012   fi
3013  
3014   fi
3015 < { $as_echo "$as_me:$LINENO: result: $ac_cv_host" >&5
3015 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
3016   $as_echo "$ac_cv_host" >&6; }
3017   case $ac_cv_host in
3018   *-*-*) ;;
3019 < *) { { $as_echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
2249 < $as_echo "$as_me: error: invalid value of canonical host" >&2;}
2250 <   { (exit 1); exit 1; }; };;
3019 > *) as_fn_error "invalid value of canonical host" "$LINENO" 5;;
3020   esac
3021   host=$ac_cv_host
3022   ac_save_IFS=$IFS; IFS='-'
# Line 2283 | Line 3052 | fi
3052    OOPSE_HOME=${prefix}/oopse
3053   fi
3054   # Check whether --enable-oopse-home was given.
3055 < if test "${enable_oopse_home+set}" = set; then
3055 > if test "${enable_oopse_home+set}" = set; then :
3056    enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
3057   fi
3058  
# Line 2293 | Line 3062 | debug=0
3062  
3063   debug=0
3064   # Check whether --enable-debug was given.
3065 < if test "${enable_debug+set}" = set; then
3065 > if test "${enable_debug+set}" = set; then :
3066    enableval=$enable_debug; debug=1
3067   fi
3068  
3069   if test "${DEBUG}"; then
3070  
3071 < cat >>confdefs.h <<\_ACEOF
2303 < #define debug 1
2304 < _ACEOF
3071 > $as_echo "#define debug 1" >>confdefs.h
3072  
3073    msg="$msg, debug mode"
3074   fi
3075  
3076  
3077   # Check whether --enable-single was given.
3078 < if test "${enable_single+set}" = set; then
3078 > if test "${enable_single+set}" = set; then :
3079    enableval=$enable_single; ok=$enableval
3080   else
3081    ok=no
3082   fi
3083  
3084   # Check whether --enable-float was given.
3085 < if test "${enable_float+set}" = set; then
3085 > if test "${enable_float+set}" = set; then :
3086    enableval=$enable_float; ok=$enableval
3087   fi
3088  
3089   if test "$ok" = "yes"; then
3090  
3091 < cat >>confdefs.h <<\_ACEOF
2325 < #define SINGLE_PRECISION 1
2326 < _ACEOF
3091 > $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
3092  
3093          USE_SINGLE_PRECISION=yes
3094  
# Line 2334 | Line 3099 | set dummy $ac_prog; ac_word=$2
3099   do
3100    # Extract the first word of "$ac_prog", so it can be a program name with args.
3101   set dummy $ac_prog; ac_word=$2
3102 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3102 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3103   $as_echo_n "checking for $ac_word... " >&6; }
3104 < if test "${ac_cv_prog_ac_cc_set+set}" = set; then
3104 > if test "${ac_cv_prog_ac_cc_set+set}" = set; then :
3105    $as_echo_n "(cached) " >&6
3106   else
3107    if test -n "$ac_cc_set"; then
# Line 2347 | Line 3112 | do
3112   do
3113    IFS=$as_save_IFS
3114    test -z "$as_dir" && as_dir=.
3115 <  for ac_exec_ext in '' $ac_executable_extensions; do
3115 >    for ac_exec_ext in '' $ac_executable_extensions; do
3116    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3117      ac_cv_prog_ac_cc_set="$ac_prog"
3118 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3118 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3119      break 2
3120    fi
3121   done
3122 < done
3122 >  done
3123   IFS=$as_save_IFS
3124  
3125   fi
3126   fi
3127   ac_cc_set=$ac_cv_prog_ac_cc_set
3128   if test -n "$ac_cc_set"; then
3129 <  { $as_echo "$as_me:$LINENO: result: $ac_cc_set" >&5
3129 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_set" >&5
3130   $as_echo "$ac_cc_set" >&6; }
3131   else
3132 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3132 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3133   $as_echo "no" >&6; }
3134   fi
3135  
# Line 2373 | Line 3138 | test -n "$ac_cc_set" || ac_cc_set="no"
3138   done
3139   test -n "$ac_cc_set" || ac_cc_set="no"
3140  
3141 <   if test $ac_cc_set != no; then
3141 >   if test $ac_cc_set != no; then :
3142  
3143       # Extract the first word of "$ac_cc_set", so it can be a program name with args.
3144   set dummy $ac_cc_set; ac_word=$2
3145 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3145 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3146   $as_echo_n "checking for $ac_word... " >&6; }
3147 < if test "${ac_cv_path_ac_cc_path+set}" = set; then
3147 > if test "${ac_cv_path_ac_cc_path+set}" = set; then :
3148    $as_echo_n "(cached) " >&6
3149   else
3150    case $ac_cc_path in
# Line 2392 | Line 3157 | do
3157   do
3158    IFS=$as_save_IFS
3159    test -z "$as_dir" && as_dir=.
3160 <  for ac_exec_ext in '' $ac_executable_extensions; do
3160 >    for ac_exec_ext in '' $ac_executable_extensions; do
3161    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3162      ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
3163 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3163 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3164      break 2
3165    fi
3166   done
3167 < done
3167 >  done
3168   IFS=$as_save_IFS
3169  
3170    test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
# Line 2408 | Line 3173 | if test -n "$ac_cc_path"; then
3173   fi
3174   ac_cc_path=$ac_cv_path_ac_cc_path
3175   if test -n "$ac_cc_path"; then
3176 <  { $as_echo "$as_me:$LINENO: result: $ac_cc_path" >&5
3176 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cc_path" >&5
3177   $as_echo "$ac_cc_path" >&6; }
3178   else
3179 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3179 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3180   $as_echo "no" >&6; }
3181   fi
3182  
3183  
3184   else
3185  
3186 <     { { $as_echo "$as_me:$LINENO: error: Specified C compiler $CC doesn't seem to exist!" >&5
2422 < $as_echo "$as_me: error: Specified C compiler $CC doesn't seem to exist!" >&2;}
2423 <   { (exit 1); exit 1; }; }
3186 >     as_fn_error "Specified C compiler $CC doesn't seem to exist!" "$LINENO" 5
3187   fi
3188  
3189 +   if test $ac_cc_path != no; then :
3190  
3191 <   if test $ac_cc_path != no; then
2428 <
2429 <     { $as_echo "$as_me:$LINENO: Will attempt to use $CC as C compiler" >&5
3191 >     { $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CC as C compiler" >&5
3192   $as_echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
3193 +     MPICC=$CC
3194 +
3195   else
3196  
3197 <     { { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified C compiler $CC" >&5
2434 < $as_echo "$as_me: error: Can't find path to user-specified C compiler $CC" >&2;}
2435 <   { (exit 1); exit 1; }; }
3197 >     as_fn_error "Can't find path to user-specified C compiler $CC" "$LINENO" 5
3198   fi
2437 –
3199   fi
3200  
3201   if test x"$CXX" != x; then
# Line 2442 | Line 3203 | set dummy $ac_prog; ac_word=$2
3203   do
3204    # Extract the first word of "$ac_prog", so it can be a program name with args.
3205   set dummy $ac_prog; ac_word=$2
3206 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3206 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3207   $as_echo_n "checking for $ac_word... " >&6; }
3208 < if test "${ac_cv_prog_ac_cxx_set+set}" = set; then
3208 > if test "${ac_cv_prog_ac_cxx_set+set}" = set; then :
3209    $as_echo_n "(cached) " >&6
3210   else
3211    if test -n "$ac_cxx_set"; then
# Line 2455 | Line 3216 | do
3216   do
3217    IFS=$as_save_IFS
3218    test -z "$as_dir" && as_dir=.
3219 <  for ac_exec_ext in '' $ac_executable_extensions; do
3219 >    for ac_exec_ext in '' $ac_executable_extensions; do
3220    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3221      ac_cv_prog_ac_cxx_set="$ac_prog"
3222 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3222 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3223      break 2
3224    fi
3225   done
3226 < done
3226 >  done
3227   IFS=$as_save_IFS
3228  
3229   fi
3230   fi
3231   ac_cxx_set=$ac_cv_prog_ac_cxx_set
3232   if test -n "$ac_cxx_set"; then
3233 <  { $as_echo "$as_me:$LINENO: result: $ac_cxx_set" >&5
3233 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_set" >&5
3234   $as_echo "$ac_cxx_set" >&6; }
3235   else
3236 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3236 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3237   $as_echo "no" >&6; }
3238   fi
3239  
# Line 2481 | Line 3242 | test -n "$ac_cxx_set" || ac_cxx_set="no"
3242   done
3243   test -n "$ac_cxx_set" || ac_cxx_set="no"
3244  
3245 <   if test $ac_cxx_set != no; then
3245 >   if test $ac_cxx_set != no; then :
3246  
3247       # Extract the first word of "$ac_cxx_set", so it can be a program name with args.
3248   set dummy $ac_cxx_set; ac_word=$2
3249 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3249 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3250   $as_echo_n "checking for $ac_word... " >&6; }
3251 < if test "${ac_cv_path_ac_cxx_path+set}" = set; then
3251 > if test "${ac_cv_path_ac_cxx_path+set}" = set; then :
3252    $as_echo_n "(cached) " >&6
3253   else
3254    case $ac_cxx_path in
# Line 2500 | Line 3261 | do
3261   do
3262    IFS=$as_save_IFS
3263    test -z "$as_dir" && as_dir=.
3264 <  for ac_exec_ext in '' $ac_executable_extensions; do
3264 >    for ac_exec_ext in '' $ac_executable_extensions; do
3265    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3266      ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
3267 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3267 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3268      break 2
3269    fi
3270   done
3271 < done
3271 >  done
3272   IFS=$as_save_IFS
3273  
3274    test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
# Line 2516 | Line 3277 | if test -n "$ac_cxx_path"; then
3277   fi
3278   ac_cxx_path=$ac_cv_path_ac_cxx_path
3279   if test -n "$ac_cxx_path"; then
3280 <  { $as_echo "$as_me:$LINENO: result: $ac_cxx_path" >&5
3280 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cxx_path" >&5
3281   $as_echo "$ac_cxx_path" >&6; }
3282   else
3283 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3283 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3284   $as_echo "no" >&6; }
3285   fi
3286  
3287  
3288   else
3289  
3290 <     { { $as_echo "$as_me:$LINENO: error: Specified C++ compiler $CXX doesn't seem to exist!" >&5
2530 < $as_echo "$as_me: error: Specified C++ compiler $CXX doesn't seem to exist!" >&2;}
2531 <   { (exit 1); exit 1; }; }
3290 >     as_fn_error "Specified C++ compiler $CXX doesn't seem to exist!" "$LINENO" 5
3291   fi
3292  
3293 +   if test $ac_cxx_path != no; then :
3294  
3295 <   if test $ac_cxx_path != no; then
2536 <
2537 <     { $as_echo "$as_me:$LINENO: Will attempt to use $CXX as C++ compiler" >&5
3295 >     { $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $CXX as C++ compiler" >&5
3296   $as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3297 +     MPICXX=$CXX
3298 +
3299   else
3300  
3301 <     { { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified C++ compiler $CXX" >&5
2542 < $as_echo "$as_me: error: Can't find path to user-specified C++ compiler $CXX" >&2;}
2543 <   { (exit 1); exit 1; }; }
3301 >     as_fn_error "Can't find path to user-specified C++ compiler $CXX" "$LINENO" 5
3302   fi
2545 –
3303   fi
3304  
3305   if test x"$FC" != x; then
# Line 2550 | Line 3307 | set dummy $ac_prog; ac_word=$2
3307   do
3308    # Extract the first word of "$ac_prog", so it can be a program name with args.
3309   set dummy $ac_prog; ac_word=$2
3310 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3310 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3311   $as_echo_n "checking for $ac_word... " >&6; }
3312 < if test "${ac_cv_prog_ac_fc_set+set}" = set; then
3312 > if test "${ac_cv_prog_ac_fc_set+set}" = set; then :
3313    $as_echo_n "(cached) " >&6
3314   else
3315    if test -n "$ac_fc_set"; then
# Line 2563 | Line 3320 | do
3320   do
3321    IFS=$as_save_IFS
3322    test -z "$as_dir" && as_dir=.
3323 <  for ac_exec_ext in '' $ac_executable_extensions; do
3323 >    for ac_exec_ext in '' $ac_executable_extensions; do
3324    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3325      ac_cv_prog_ac_fc_set="$ac_prog"
3326 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3326 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3327      break 2
3328    fi
2572 – done
3329   done
3330 +  done
3331   IFS=$as_save_IFS
3332  
3333   fi
3334   fi
3335   ac_fc_set=$ac_cv_prog_ac_fc_set
3336   if test -n "$ac_fc_set"; then
3337 <  { $as_echo "$as_me:$LINENO: result: $ac_fc_set" >&5
3337 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_set" >&5
3338   $as_echo "$ac_fc_set" >&6; }
3339   else
3340 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3340 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3341   $as_echo "no" >&6; }
3342   fi
3343  
# Line 2589 | Line 3346 | test -n "$ac_fc_set" || ac_fc_set="no"
3346   done
3347   test -n "$ac_fc_set" || ac_fc_set="no"
3348  
3349 <   if test $ac_fc_set != no; then
3349 >   if test $ac_fc_set != no; then :
3350  
3351       # Extract the first word of "$ac_fc_set", so it can be a program name with args.
3352   set dummy $ac_fc_set; ac_word=$2
3353 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3353 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3354   $as_echo_n "checking for $ac_word... " >&6; }
3355 < if test "${ac_cv_path_ac_fc_path+set}" = set; then
3355 > if test "${ac_cv_path_ac_fc_path+set}" = set; then :
3356    $as_echo_n "(cached) " >&6
3357   else
3358    case $ac_fc_path in
# Line 2608 | Line 3365 | do
3365   do
3366    IFS=$as_save_IFS
3367    test -z "$as_dir" && as_dir=.
3368 <  for ac_exec_ext in '' $ac_executable_extensions; do
3368 >    for ac_exec_ext in '' $ac_executable_extensions; do
3369    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3370      ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
3371 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3371 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3372      break 2
3373    fi
3374   done
3375 < done
3375 >  done
3376   IFS=$as_save_IFS
3377  
3378    test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
# Line 2624 | Line 3381 | if test -n "$ac_fc_path"; then
3381   fi
3382   ac_fc_path=$ac_cv_path_ac_fc_path
3383   if test -n "$ac_fc_path"; then
3384 <  { $as_echo "$as_me:$LINENO: result: $ac_fc_path" >&5
3384 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_fc_path" >&5
3385   $as_echo "$ac_fc_path" >&6; }
3386   else
3387 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3387 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3388   $as_echo "no" >&6; }
3389   fi
3390  
3391  
3392   else
3393  
3394 <     { { $as_echo "$as_me:$LINENO: error: Specified Fortran compiler $FC doesn't seem to exist!" >&5
2638 < $as_echo "$as_me: error: Specified Fortran compiler $FC doesn't seem to exist!" >&2;}
2639 <   { (exit 1); exit 1; }; }
3394 >     as_fn_error "Specified Fortran compiler $FC doesn't seem to exist!" "$LINENO" 5
3395   fi
3396  
3397 +   if test $ac_fc_path != no; then :
3398  
3399 <   if test $ac_fc_path != no; then
2644 <
2645 <     { $as_echo "$as_me:$LINENO: Will attempt to use $FC as Fortran compiler" >&5
3399 >     { $as_echo "$as_me:${as_lineno-$LINENO}: Will attempt to use $FC as Fortran compiler" >&5
3400   $as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3401 < else
3401 >     MPIFC=$FC
3402  
2649 –     { { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified Fortran compiler $FC" >&5
2650 – $as_echo "$as_me: error: Can't find path to user-specified Fortran compiler $FC" >&2;}
2651 –   { (exit 1); exit 1; }; }
2652 – fi
2653 –
2654 – fi
2655 –
2656 –
2657 –
2658 –
2659 – # Check whether --with-mpi was given.
2660 – if test "${with_mpi+set}" = set; then
2661 –  withval=$with_mpi;
3403   else
2663 –  with_mpi="auto"
2664 – fi
3404  
3405 < if test "x$with_mpi" != "xno"; then
2667 <
2668 <
2669 < for ac_prog in $CC openmpicc mpicc
2670 < do
2671 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
2672 < set dummy $ac_prog; ac_word=$2
2673 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2674 < $as_echo_n "checking for $ac_word... " >&6; }
2675 < if test "${ac_cv_prog_acx_mpi_mpicc+set}" = set; then
2676 <  $as_echo_n "(cached) " >&6
2677 < else
2678 <  if test -n "$acx_mpi_mpicc"; then
2679 <  ac_cv_prog_acx_mpi_mpicc="$acx_mpi_mpicc" # Let the user override the test.
2680 < else
2681 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2682 < for as_dir in $PATH
2683 < do
2684 <  IFS=$as_save_IFS
2685 <  test -z "$as_dir" && as_dir=.
2686 <  for ac_exec_ext in '' $ac_executable_extensions; do
2687 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2688 <    ac_cv_prog_acx_mpi_mpicc="$ac_prog"
2689 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2690 <    break 2
2691 <  fi
2692 < done
2693 < done
2694 < IFS=$as_save_IFS
2695 <
2696 < fi
2697 < fi
2698 < acx_mpi_mpicc=$ac_cv_prog_acx_mpi_mpicc
2699 < if test -n "$acx_mpi_mpicc"; then
2700 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicc" >&5
2701 < $as_echo "$acx_mpi_mpicc" >&6; }
2702 < else
2703 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2704 < $as_echo "no" >&6; }
2705 < fi
2706 <
2707 <
2708 <  test -n "$acx_mpi_mpicc" && break
2709 < done
2710 < test -n "$acx_mpi_mpicc" || acx_mpi_mpicc="no"
2711 <
2712 < if test $acx_mpi_mpicc != no; then
2713 <
2714 <  # Extract the first word of "$acx_mpi_mpicc", so it can be a program name with args.
2715 < set dummy $acx_mpi_mpicc; ac_word=$2
2716 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2717 < $as_echo_n "checking for $ac_word... " >&6; }
2718 < if test "${ac_cv_path_acx_mpi_mpicc_path+set}" = set; then
2719 <  $as_echo_n "(cached) " >&6
2720 < else
2721 <  case $acx_mpi_mpicc_path in
2722 <  [\\/]* | ?:[\\/]*)
2723 <  ac_cv_path_acx_mpi_mpicc_path="$acx_mpi_mpicc_path" # Let the user override the test with a path.
2724 <  ;;
2725 <  *)
2726 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2727 < for as_dir in $PATH
2728 < do
2729 <  IFS=$as_save_IFS
2730 <  test -z "$as_dir" && as_dir=.
2731 <  for ac_exec_ext in '' $ac_executable_extensions; do
2732 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2733 <    ac_cv_path_acx_mpi_mpicc_path="$as_dir/$ac_word$ac_exec_ext"
2734 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2735 <    break 2
2736 <  fi
2737 < done
2738 < done
2739 < IFS=$as_save_IFS
2740 <
2741 <  test -z "$ac_cv_path_acx_mpi_mpicc_path" && ac_cv_path_acx_mpi_mpicc_path="no"
2742 <  ;;
2743 < esac
2744 < fi
2745 < acx_mpi_mpicc_path=$ac_cv_path_acx_mpi_mpicc_path
2746 < if test -n "$acx_mpi_mpicc_path"; then
2747 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicc_path" >&5
2748 < $as_echo "$acx_mpi_mpicc_path" >&6; }
2749 < else
2750 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2751 < $as_echo "no" >&6; }
3405 >     as_fn_error "Can't find path to user-specified Fortran compiler $FC" "$LINENO" 5
3406   fi
2753 –
2754 –
3407   fi
3408  
2757 – for ac_prog in $FC openmpif90 mpif90
2758 – do
2759 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
2760 – set dummy $ac_prog; ac_word=$2
2761 – { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2762 – $as_echo_n "checking for $ac_word... " >&6; }
2763 – if test "${ac_cv_prog_acx_mpi_mpif90+set}" = set; then
2764 –  $as_echo_n "(cached) " >&6
2765 – else
2766 –  if test -n "$acx_mpi_mpif90"; then
2767 –  ac_cv_prog_acx_mpi_mpif90="$acx_mpi_mpif90" # Let the user override the test.
2768 – else
2769 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2770 – for as_dir in $PATH
2771 – do
2772 –  IFS=$as_save_IFS
2773 –  test -z "$as_dir" && as_dir=.
2774 –  for ac_exec_ext in '' $ac_executable_extensions; do
2775 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2776 –    ac_cv_prog_acx_mpi_mpif90="$ac_prog"
2777 –    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2778 –    break 2
2779 –  fi
2780 – done
2781 – done
2782 – IFS=$as_save_IFS
3409  
3410 < fi
2785 < fi
2786 < acx_mpi_mpif90=$ac_cv_prog_acx_mpi_mpif90
2787 < if test -n "$acx_mpi_mpif90"; then
2788 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpif90" >&5
2789 < $as_echo "$acx_mpi_mpif90" >&6; }
2790 < else
2791 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2792 < $as_echo "no" >&6; }
2793 < fi
2794 <
2795 <
2796 <  test -n "$acx_mpi_mpif90" && break
2797 < done
2798 < test -n "$acx_mpi_mpif90" || acx_mpi_mpif90="no"
2799 <
2800 < if test $acx_mpi_mpif90 != no; then
2801 <
2802 <  # Extract the first word of "$acx_mpi_mpif90", so it can be a program name with args.
2803 < set dummy $acx_mpi_mpif90; ac_word=$2
2804 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2805 < $as_echo_n "checking for $ac_word... " >&6; }
2806 < if test "${ac_cv_path_acx_mpi_mpif90_path+set}" = set; then
2807 <  $as_echo_n "(cached) " >&6
2808 < else
2809 <  case $acx_mpi_mpif90_path in
2810 <  [\\/]* | ?:[\\/]*)
2811 <  ac_cv_path_acx_mpi_mpif90_path="$acx_mpi_mpif90_path" # Let the user override the test with a path.
2812 <  ;;
2813 <  *)
2814 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2815 < for as_dir in $PATH
2816 < do
2817 <  IFS=$as_save_IFS
2818 <  test -z "$as_dir" && as_dir=.
2819 <  for ac_exec_ext in '' $ac_executable_extensions; do
2820 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2821 <    ac_cv_path_acx_mpi_mpif90_path="$as_dir/$ac_word$ac_exec_ext"
2822 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2823 <    break 2
2824 <  fi
2825 < done
2826 < done
2827 < IFS=$as_save_IFS
2828 <
2829 <  test -z "$ac_cv_path_acx_mpi_mpif90_path" && ac_cv_path_acx_mpi_mpif90_path="no"
2830 <  ;;
2831 < esac
2832 < fi
2833 < acx_mpi_mpif90_path=$ac_cv_path_acx_mpi_mpif90_path
2834 < if test -n "$acx_mpi_mpif90_path"; then
2835 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpif90_path" >&5
2836 < $as_echo "$acx_mpi_mpif90_path" >&6; }
2837 < else
2838 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2839 < $as_echo "no" >&6; }
2840 < fi
2841 <
2842 <
2843 < fi
2844 <
2845 < for ac_prog in $CXX openmpicxx openmpiCC openmpic++ mpicxx mpiCC mpic++
2846 < do
2847 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
2848 < set dummy $ac_prog; ac_word=$2
2849 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2850 < $as_echo_n "checking for $ac_word... " >&6; }
2851 < if test "${ac_cv_prog_acx_mpi_mpicxx+set}" = set; then
2852 <  $as_echo_n "(cached) " >&6
2853 < else
2854 <  if test -n "$acx_mpi_mpicxx"; then
2855 <  ac_cv_prog_acx_mpi_mpicxx="$acx_mpi_mpicxx" # Let the user override the test.
2856 < else
2857 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2858 < for as_dir in $PATH
2859 < do
2860 <  IFS=$as_save_IFS
2861 <  test -z "$as_dir" && as_dir=.
2862 <  for ac_exec_ext in '' $ac_executable_extensions; do
2863 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2864 <    ac_cv_prog_acx_mpi_mpicxx="$ac_prog"
2865 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2866 <    break 2
2867 <  fi
2868 < done
2869 < done
2870 < IFS=$as_save_IFS
2871 <
2872 < fi
2873 < fi
2874 < acx_mpi_mpicxx=$ac_cv_prog_acx_mpi_mpicxx
2875 < if test -n "$acx_mpi_mpicxx"; then
2876 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicxx" >&5
2877 < $as_echo "$acx_mpi_mpicxx" >&6; }
2878 < else
2879 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2880 < $as_echo "no" >&6; }
2881 < fi
2882 <
2883 <
2884 <  test -n "$acx_mpi_mpicxx" && break
2885 < done
2886 < test -n "$acx_mpi_mpicxx" || acx_mpi_mpicxx="no"
2887 <
2888 < if test $acx_mpi_mpicxx != no; then
2889 <
2890 <  # Extract the first word of "$acx_mpi_mpicxx", so it can be a program name with args.
2891 < set dummy $acx_mpi_mpicxx; ac_word=$2
2892 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2893 < $as_echo_n "checking for $ac_word... " >&6; }
2894 < if test "${ac_cv_path_acx_mpi_mpicxx_path+set}" = set; then
2895 <  $as_echo_n "(cached) " >&6
2896 < else
2897 <  case $acx_mpi_mpicxx_path in
2898 <  [\\/]* | ?:[\\/]*)
2899 <  ac_cv_path_acx_mpi_mpicxx_path="$acx_mpi_mpicxx_path" # Let the user override the test with a path.
2900 <  ;;
2901 <  *)
2902 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2903 < for as_dir in $PATH
2904 < do
2905 <  IFS=$as_save_IFS
2906 <  test -z "$as_dir" && as_dir=.
2907 <  for ac_exec_ext in '' $ac_executable_extensions; do
2908 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2909 <    ac_cv_path_acx_mpi_mpicxx_path="$as_dir/$ac_word$ac_exec_ext"
2910 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2911 <    break 2
2912 <  fi
2913 < done
2914 < done
2915 < IFS=$as_save_IFS
2916 <
2917 <  test -z "$ac_cv_path_acx_mpi_mpicxx_path" && ac_cv_path_acx_mpi_mpicxx_path="no"
2918 <  ;;
2919 < esac
2920 < fi
2921 < acx_mpi_mpicxx_path=$ac_cv_path_acx_mpi_mpicxx_path
2922 < if test -n "$acx_mpi_mpicxx_path"; then
2923 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicxx_path" >&5
2924 < $as_echo "$acx_mpi_mpicxx_path" >&6; }
2925 < else
2926 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2927 < $as_echo "no" >&6; }
2928 < fi
2929 <
2930 <
2931 < fi
2932 <
2933 < if test $acx_mpi_mpicc = no; then
2934 <
2935 <  if test $acx_mpi_mpicxx = no; then
2936 <
2937 <    acx_mpi_compiler=no
2938 <
2939 < else
2940 <
2941 <    acx_mpi_compiler=$acx_mpi_mpicxx
2942 <    acx_mpi_compiler_path=$acx_mpi_mpicxx_path
2943 < fi
2944 <
2945 <
2946 < else
2947 <
2948 <  if test $acx_mpi_mpicxx = no; then
2949 <
2950 <    acx_mpi_compiler=$acx_mpi_mpicc
2951 <    acx_mpi_compiler_path=$acx_mpi_mpicc_path
2952 <
2953 < else
2954 <
2955 <    { $as_echo "$as_me:$LINENO: checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx" >&5
2956 < $as_echo_n "checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx... " >&6; }
2957 <    ac_ext=cpp
3410 > ac_ext=cpp
3411   ac_cpp='$CXXCPP $CPPFLAGS'
3412   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3413   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3414   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3415  
2963 –    cat >conftest.$ac_ext <<_ACEOF
2964 – /* confdefs.h.  */
2965 – _ACEOF
2966 – cat confdefs.h >>conftest.$ac_ext
2967 – cat >>conftest.$ac_ext <<_ACEOF
2968 – /* end confdefs.h.  */
2969 –
2970 – #include <mpi.h>
2971 –
2972 – int
2973 – main ()
2974 – {
2975 –
2976 – MPI_Finalize();
2977 –
2978 –  ;
2979 –  return 0;
2980 – }
2981 – _ACEOF
2982 –    if { (ac_try="$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5"
2983 – case "(($ac_try" in
2984 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2985 –  *) ac_try_echo=$ac_try;;
2986 – esac
2987 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
2988 – $as_echo "$ac_try_echo") >&5
2989 –  (eval "$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5") 2>conftest.er1
2990 –  ac_status=$?
2991 –  grep -v '^ *+' conftest.er1 >conftest.err
2992 –  rm -f conftest.er1
2993 –  cat conftest.err >&5
2994 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
2995 –  (exit $ac_status); } && {
2996 –         test -z "$ac_cxx_werror_flag" ||
2997 –         test ! -s conftest.err
2998 –       } && test -s conftest.$ac_objext; then
2999 –
3000 –      acx_mpi_compiler=$acx_mpi_mpicxx
3001 –      acx_mpi_compiler_path=$acx_mpi_mpicxx_path
3002 –
3003 – else
3004 –
3005 –      acx_mpi_compiler=$acx_mpi_mpicc
3006 –      acx_mpi_compiler_path=$acx_mpi_mpicc_path
3007 – fi
3008 –
3009 –    ac_ext=c
3010 – ac_cpp='$CPP $CPPFLAGS'
3011 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3012 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3013 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
3014 –
3015 –    { $as_echo "$as_me:$LINENO: result: $acx_mpi_compiler" >&5
3016 – $as_echo "$acx_mpi_compiler" >&6; }
3017 – fi
3018 –
3019 – fi
3020 –
3021 – { $as_echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
3022 – $as_echo_n "checking whether mpif.h is usable... " >&6; }
3023 – ac_ext=${ac_fc_srcext-f}
3024 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
3025 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
3026 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
3027 –
3028 – ac_save_ext=$ac_ext
3029 – ac_ext=F90
3030 – rm -f conftest*
3031 – cat >conftest.$ac_ext <<EOF
3032 – program main
3033 –   include 'mpif.h'
3034 –   call MPI_Init
3035 – end
3036 – EOF
3037 – if $acx_mpi_mpif90_path -c conftest.$ac_ext > conftest.out 2>&1 ; then
3038 –        acx_mpi_f90_compiler=yes
3039 –        { $as_echo "$as_me:$LINENO: result: yes" >&5
3040 – $as_echo "yes" >&6; }
3041 – else
3042 –        if test -s conftest.out ; then
3043 –                cat conftest.out >> config.log
3044 –        fi
3045 –        acx_mpi_f90_compiler=no
3046 –        { $as_echo "$as_me:$LINENO: result: no! Check MPI fortran include paths" >&5
3047 – $as_echo "no! Check MPI fortran include paths" >&6; }
3048 – fi
3049 – rm -f conftest*
3050 – ac_ext=$ac_save_ext
3051 – ac_ext=c
3052 – ac_cpp='$CPP $CPPFLAGS'
3053 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3054 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3055 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
3056 –
3057 – if test $acx_mpi_compiler = no || test $acx_mpi_f90_compiler = no; then
3058 –
3059 – acx_cv_mpi_implementation=no
3060 – else
3061 –  { $as_echo "$as_me:$LINENO: checking for the MPI implementation flavor" >&5
3062 – $as_echo_n "checking for the MPI implementation flavor... " >&6; }
3063 – if test "${acx_cv_mpi_implementation+set}" = set; then
3064 –  $as_echo_n "(cached) " >&6
3065 – else
3066 –  acx_cv_mpi_implementation=no
3067 – if { (ac_try="grep -q LAM $acx_mpi_compiler_path"
3068 – case "(($ac_try" in
3069 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3070 –  *) ac_try_echo=$ac_try;;
3071 – esac
3072 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3073 – $as_echo "$ac_try_echo") >&5
3074 –  (eval "grep -q LAM $acx_mpi_compiler_path") 2>conftest.er1
3075 –  ac_status=$?
3076 –  grep -v '^ *+' conftest.er1 >conftest.err
3077 –  rm -f conftest.er1
3078 –  cat conftest.err >&5
3079 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3080 –  (exit $ac_status); }; then
3081 –
3082 –  acx_cv_mpi_implementation=lammpi
3083 –
3084 – else
3085 –
3086 –  if { (ac_try="grep -q showme $acx_mpi_compiler_path"
3087 – case "(($ac_try" in
3088 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3089 –  *) ac_try_echo=$ac_try;;
3090 – esac
3091 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3092 – $as_echo "$ac_try_echo") >&5
3093 –  (eval "grep -q showme $acx_mpi_compiler_path") 2>conftest.er1
3094 –  ac_status=$?
3095 –  grep -v '^ *+' conftest.er1 >conftest.err
3096 –  rm -f conftest.er1
3097 –  cat conftest.err >&5
3098 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3099 –  (exit $ac_status); }; then
3100 –
3101 –    acx_cv_mpi_implementation=openmpi
3102 –
3103 – else
3104 –
3105 –    if { (ac_try="grep -q MPICH $acx_mpi_compiler_path"
3106 – case "(($ac_try" in
3107 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3108 –  *) ac_try_echo=$ac_try;;
3109 – esac
3110 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3111 – $as_echo "$ac_try_echo") >&5
3112 –  (eval "grep -q MPICH $acx_mpi_compiler_path") 2>conftest.er1
3113 –  ac_status=$?
3114 –  grep -v '^ *+' conftest.er1 >conftest.err
3115 –  rm -f conftest.er1
3116 –  cat conftest.err >&5
3117 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3118 –  (exit $ac_status); }; then
3119 –
3120 –      acx_cv_mpi_implementation=mpich
3121 –
3122 – else
3123 –  acx_cv_mpi_implementation=$with_mpi
3124 – fi
3125 –
3126 – fi
3127 –
3128 – fi
3129 –
3130 – fi
3131 – { $as_echo "$as_me:$LINENO: result: $acx_cv_mpi_implementation" >&5
3132 – $as_echo "$acx_cv_mpi_implementation" >&6; }
3133 –
3134 – fi
3135 – case $acx_cv_mpi_implementation in
3136 – (lammpi)
3137 –
3138 – cat >>confdefs.h <<\_ACEOF
3139 – #define MPI_IS_LAMMPI 1
3140 – _ACEOF
3141 –
3142 –  ;;
3143 – (openmpi)
3144 –
3145 – cat >>confdefs.h <<\_ACEOF
3146 – #define MPI_IS_OPENMPI 1
3147 – _ACEOF
3148 –
3149 –  ;;
3150 – (mpich)
3151 –
3152 – cat >>confdefs.h <<\_ACEOF
3153 – #define MPI_IS_MPICH 1
3154 – _ACEOF
3155 –
3156 –  ;;
3157 – esac
3158 – if test $acx_cv_mpi_implementation = no; then
3159 –
3160 – acx_mpi_cflags=""
3161 – acx_mpi_libs=""
3162 – USE_MPI="no"
3163 –        { $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3164 – $as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3165 – else
3166 –
3167 –
3168 – { $as_echo "$as_me:$LINENO: checking how to compile MPI-C code" >&5
3169 – $as_echo_n "checking how to compile MPI-C code... " >&6; }
3170 – if test "${acx_mpi_cflags+set}" = set; then
3171 –  $as_echo_n "(cached) " >&6
3172 – else
3173 –
3174 – case $acx_cv_mpi_implementation in
3175 –  (lammpi)
3176 –    cfo="--showme:compile"
3177 –    ;;
3178 –  (openmpi)
3179 –    cfo="--showme:compile"
3180 –    ;;
3181 –  (mpich)
3182 –    case "$acx_mpi_compiler_path" in
3183 –      (*mpiCC)
3184 –        sc_cv_cn="-CC="
3185 –        ;;
3186 –      (*mpicxx)
3187 –        sc_cv_cn="-cxx="
3188 –        ;;
3189 –      (*mpicc)
3190 –        sc_cv_cn="-cc="
3191 –        ;;
3192 –      (*)
3193 –        sc_cv_cn=""
3194 –        ;;
3195 –    esac
3196 –    cfo="-compile_info $sc_cv_cn"
3197 –    ;;
3198 – esac
3199 – $as_echo "$as_me:$LINENO: mpi_pre_cflags=\"\`$acx_mpi_compiler_path $cfo || echo ' no'\`\"" >&5
3200 – mpi_pre_cflags="`$acx_mpi_compiler_path $cfo 2>conftest.er1 || echo ' no'`"
3201 – grep -v '^ *+' conftest.er1 >conftest.err
3202 – rm -f conftest.er1
3203 – cat conftest.err >&5
3204 – $as_echo "$as_me:$LINENO: mpi_pre_cflags = $mpi_pre_cflags" >&5
3205 – case "$mpi_pre_cflags" in
3206 –  (*no)
3207 –    acx_mpi_cflags=no
3208 –    acx_mpi_cflags="no"
3209 –    ;;
3210 –  (*)
3211 –    acx_mpi_tmp_mode="normal"
3212 –  acx_mpi_tmp_prefix=""
3213 –  eval "acx_mpi_cflags=\"\""
3214 –  for acx_mpi_tmp in $mpi_pre_cflags; do
3215 –    case "$acx_mpi_tmp_mode" in
3216 –      (normal)
3217 –        case "$acx_mpi_tmp" in
3218 –          (-I|-D)
3219 –            acx_mpi_tmp_prefix="$acx_mpi_tmp"
3220 –            acx_mpi_tmp_mode="accept"
3221 –            ;;
3222 –          (-I*|-D*)
3223 –            eval "acx_mpi_cflags=\"`eval 'as_val=${'\\acx_mpi_cflags'}
3224 –                 $as_echo "$as_val"'` \$acx_mpi_tmp\""
3225 –            ;;
3226 –          (-L|-l)
3227 –            acx_mpi_tmp_mode="skip"
3228 –            ;;
3229 –          (*)
3230 –            ;;
3231 –        esac
3232 –        ;;
3233 –      (accept)
3234 –        eval "acx_mpi_cflags=\"`eval 'as_val=${'\\acx_mpi_cflags'}
3235 –                 $as_echo "$as_val"'` \$acx_mpi_tmp_prefix \$acx_mpi_tmp\""
3236 –        ;;
3237 –      (skip)
3238 –        ;;
3239 –    esac
3240 –  done
3241 –
3242 –    ;;
3243 – esac
3244 –
3245 – fi
3246 – { $as_echo "$as_me:$LINENO: result: $acx_mpi_cflags" >&5
3247 – $as_echo "$acx_mpi_cflags" >&6; }
3248 –
3249 –
3250 – { $as_echo "$as_me:$LINENO: checking how to link MPI-C code" >&5
3251 – $as_echo_n "checking how to link MPI-C code... " >&6; }
3252 – if test "${acx_mpi_libs+set}" = set; then
3253 –  $as_echo_n "(cached) " >&6
3254 – else
3255 –
3256 – case $acx_cv_mpi_implementation in
3257 –  (lammpi)
3258 –    lfo="--showme:compile --showme:link"
3259 –    ;;
3260 –  (openmpi)
3261 –    lfo="--showme:link"
3262 –    ;;
3263 –  (mpich)
3264 –    case "$acx_mpi_compiler_path" in
3265 –      (*mpiCC)
3266 –        sc_cv_cn="-CC="
3267 –        ;;
3268 –      (*mpicxx)
3269 –        sc_cv_cn="-cxx="
3270 –        ;;
3271 –      (*mpicc)
3272 –        sc_cv_cn="-cc="
3273 –        ;;
3274 –      (*)
3275 –        sc_cv_cn=""
3276 –        ;;
3277 –    esac
3278 –    lfo="-link_info $sc_cv_cn"
3279 –    ;;
3280 – esac
3281 – $as_echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_compiler_path $lfo || echo ' no'\`\"" >&5
3282 – mpi_pre_libs="`$acx_mpi_compiler_path $lfo 2>conftest.er1 || echo ' no'`"
3283 – grep -v '^ *+' conftest.er1 >conftest.err
3284 – rm -f conftest.er1
3285 – cat conftest.err >&5
3286 – $as_echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3287 – case "$mpi_pre_libs" in
3288 –  (*no)
3289 –    acx_mpi_libs=no
3290 –    ;;
3291 –  (*)
3292 –    acx_mpi_libs="$mpi_pre_libs"
3293 –    ;;
3294 – esac
3295 –
3296 – fi
3297 – { $as_echo "$as_me:$LINENO: result: $acx_mpi_libs" >&5
3298 – $as_echo "$acx_mpi_libs" >&6; }
3299 –
3300 – if test $acx_mpi_mpif90_path != no; then
3301 –
3302 –
3303 –  { $as_echo "$as_me:$LINENO: checking how to link MPI-Fortran code" >&5
3304 – $as_echo_n "checking how to link MPI-Fortran code... " >&6; }
3305 – if test "${acx_mpi90_libs+set}" = set; then
3306 –  $as_echo_n "(cached) " >&6
3307 – else
3308 –
3309 –    $as_echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_mpif90_path $lfo || echo \" no\"\`\"" >&5
3310 –    mpi_pre_libs="`$acx_mpi_mpif90_path $lfo 2>conftest.er1 || echo " no"`"
3311 –    grep -v '^ *+' conftest.er1 >conftest.err
3312 –    rm -f conftest.er1
3313 –    cat conftest.err >&5
3314 –    $as_echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3315 –    case "$mpi_pre_libs" in
3316 –      (*no)
3317 –        acx_mpi90_libs=no
3318 –        ;;
3319 –      (*)
3320 –        acx_mpi90_libs="$mpi_pre_libs"
3321 –        ;;
3322 –    esac
3323 –
3324 – fi
3325 – { $as_echo "$as_me:$LINENO: result: $acx_mpi90_libs" >&5
3326 – $as_echo "$acx_mpi90_libs" >&6; }
3327 –
3328 –
3329 – fi
3330 –
3331 – if test "$acx_mpi_cflags" = no -o "$acx_mpi_libs" = no; then
3332 –
3333 – acx_mpi_cflags=""
3334 – acx_mpi_libs=""
3335 – USE_MPI="no"
3336 –        { $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3337 – $as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3338 – else
3339 –
3340 – MPI_CPPFLAGS=$acx_mpi_cflags
3341 –
3342 – MPI_LIBS=$acx_mpi_libs
3343 –
3344 – if test "$acx_mpi90_libs" != no; then
3345 –  MPI90_LIBS=$acx_mpi90_libs
3346 –
3347 – fi
3348 –
3349 – USE_MPI="yes"
3350 – fi
3351 –
3352 –
3353 – fi
3354 –
3355 –
3356 – fi
3357 –
3358 –
3359 –
3360 – # Checks for programs.
3416   ac_ext=cpp
3417   ac_cpp='$CXXCPP $CPPFLAGS'
3418   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 3368 | Line 3423 | if test -z "$CXX"; then
3423      CXX=$CCC
3424    else
3425      if test -n "$ac_tool_prefix"; then
3426 <  for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3426 >  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3427    do
3428      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3429   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3430 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3430 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3431   $as_echo_n "checking for $ac_word... " >&6; }
3432 < if test "${ac_cv_prog_CXX+set}" = set; then
3432 > if test "${ac_cv_prog_CXX+set}" = set; then :
3433    $as_echo_n "(cached) " >&6
3434   else
3435    if test -n "$CXX"; then
# Line 3385 | Line 3440 | do
3440   do
3441    IFS=$as_save_IFS
3442    test -z "$as_dir" && as_dir=.
3443 <  for ac_exec_ext in '' $ac_executable_extensions; do
3443 >    for ac_exec_ext in '' $ac_executable_extensions; do
3444    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3445      ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3446 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3446 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3447      break 2
3448    fi
3449   done
3450 < done
3450 >  done
3451   IFS=$as_save_IFS
3452  
3453   fi
3454   fi
3455   CXX=$ac_cv_prog_CXX
3456   if test -n "$CXX"; then
3457 <  { $as_echo "$as_me:$LINENO: result: $CXX" >&5
3457 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
3458   $as_echo "$CXX" >&6; }
3459   else
3460 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3460 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3461   $as_echo "no" >&6; }
3462   fi
3463  
# Line 3412 | Line 3467 | if test -z "$CXX"; then
3467   fi
3468   if test -z "$CXX"; then
3469    ac_ct_CXX=$CXX
3470 <  for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3470 >  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
3471   do
3472    # Extract the first word of "$ac_prog", so it can be a program name with args.
3473   set dummy $ac_prog; ac_word=$2
3474 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3474 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3475   $as_echo_n "checking for $ac_word... " >&6; }
3476 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3476 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
3477    $as_echo_n "(cached) " >&6
3478   else
3479    if test -n "$ac_ct_CXX"; then
# Line 3429 | Line 3484 | do
3484   do
3485    IFS=$as_save_IFS
3486    test -z "$as_dir" && as_dir=.
3487 <  for ac_exec_ext in '' $ac_executable_extensions; do
3487 >    for ac_exec_ext in '' $ac_executable_extensions; do
3488    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3489      ac_cv_prog_ac_ct_CXX="$ac_prog"
3490 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3490 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3491      break 2
3492    fi
3493   done
3494 < done
3494 >  done
3495   IFS=$as_save_IFS
3496  
3497   fi
3498   fi
3499   ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3500   if test -n "$ac_ct_CXX"; then
3501 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3501 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
3502   $as_echo "$ac_ct_CXX" >&6; }
3503   else
3504 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3504 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3505   $as_echo "no" >&6; }
3506   fi
3507  
# Line 3459 | Line 3514 | yes:)
3514    else
3515      case $cross_compiling:$ac_tool_warned in
3516   yes:)
3517 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
3518 < whose name does not start with the host triplet.  If you think this
3464 < configuration is useful to you, please write to autoconf@gnu.org." >&5
3465 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
3466 < whose name does not start with the host triplet.  If you think this
3467 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
3517 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3518 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3519   ac_tool_warned=yes ;;
3520   esac
3521      CXX=$ac_ct_CXX
# Line 3474 | Line 3525 | fi
3525    fi
3526   fi
3527   # Provide some information about the compiler.
3528 < $as_echo "$as_me:$LINENO: checking for C++ compiler version" >&5
3528 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3529   set X $ac_compile
3530   ac_compiler=$2
3531 < { (ac_try="$ac_compiler --version >&5"
3531 > for ac_option in --version -v -V -qversion; do
3532 >  { { ac_try="$ac_compiler $ac_option >&5"
3533   case "(($ac_try" in
3534    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3535    *) ac_try_echo=$ac_try;;
3536   esac
3537 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3538 < $as_echo "$ac_try_echo") >&5
3539 <  (eval "$ac_compiler --version >&5") 2>&5
3537 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3538 > $as_echo "$ac_try_echo"; } >&5
3539 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3540    ac_status=$?
3541 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3542 <  (exit $ac_status); }
3543 < { (ac_try="$ac_compiler -v >&5"
3544 < case "(($ac_try" in
3545 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3546 <  *) ac_try_echo=$ac_try;;
3547 < esac
3548 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3549 < $as_echo "$ac_try_echo") >&5
3550 <  (eval "$ac_compiler -v >&5") 2>&5
3499 <  ac_status=$?
3500 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3501 <  (exit $ac_status); }
3502 < { (ac_try="$ac_compiler -V >&5"
3503 < case "(($ac_try" in
3504 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3505 <  *) ac_try_echo=$ac_try;;
3506 < esac
3507 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3508 < $as_echo "$ac_try_echo") >&5
3509 <  (eval "$ac_compiler -V >&5") 2>&5
3510 <  ac_status=$?
3511 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3512 <  (exit $ac_status); }
3541 >  if test -s conftest.err; then
3542 >    sed '10a\
3543 > ... rest of stderr output deleted ...
3544 >         10q' conftest.err >conftest.er1
3545 >    cat conftest.er1 >&5
3546 >    rm -f conftest.er1 conftest.err
3547 >  fi
3548 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3549 >  test $ac_status = 0; }
3550 > done
3551  
3552 < cat >conftest.$ac_ext <<_ACEOF
3515 < /* confdefs.h.  */
3516 < _ACEOF
3517 < cat confdefs.h >>conftest.$ac_ext
3518 < cat >>conftest.$ac_ext <<_ACEOF
3552 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3553   /* end confdefs.h.  */
3554 <
3554 > #include <stdio.h>
3555   int
3556   main ()
3557   {
3558 + FILE *f = fopen ("conftest.out", "w");
3559 + return ferror (f) || fclose (f) != 0;
3560  
3561    ;
3562    return 0;
3563   }
3564   _ACEOF
3565   ac_clean_files_save=$ac_clean_files
3566 < ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3566 > ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out conftest.out"
3567   # Try to create an executable without -o first, disregard a.out.
3568   # It will help us diagnose broken compilers, and finding out an intuition
3569   # of exeext.
3570 < { $as_echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
3570 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3571   $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3572   ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3573  
# Line 3548 | Line 3584 | rm -f $ac_rmfiles
3584   done
3585   rm -f $ac_rmfiles
3586  
3587 < if { (ac_try="$ac_link_default"
3587 > if { { ac_try="$ac_link_default"
3588   case "(($ac_try" in
3589    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3590    *) ac_try_echo=$ac_try;;
3591   esac
3592 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3593 < $as_echo "$ac_try_echo") >&5
3592 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3593 > $as_echo "$ac_try_echo"; } >&5
3594    (eval "$ac_link_default") 2>&5
3595    ac_status=$?
3596 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3597 <  (exit $ac_status); }; then
3596 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3597 >  test $ac_status = 0; }; then :
3598    # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3599   # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3600   # in a Makefile.  We should not override ac_cv_exeext if it was cached,
# Line 3575 | Line 3611 | do
3611          # certainly right.
3612          break;;
3613      *.* )
3614 <        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3614 >        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3615          then :; else
3616             ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3617          fi
# Line 3594 | Line 3630 | fi
3630   else
3631    ac_file=''
3632   fi
3633 <
3598 < { $as_echo "$as_me:$LINENO: result: $ac_file" >&5
3633 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3634   $as_echo "$ac_file" >&6; }
3635 < if test -z "$ac_file"; then
3635 > if test -z "$ac_file"; then :
3636    $as_echo "$as_me: failed program was:" >&5
3637   sed 's/^/| /' conftest.$ac_ext >&5
3638  
3639 < { { $as_echo "$as_me:$LINENO: error: C++ compiler cannot create executables
3640 < See \`config.log' for more details." >&5
3641 < $as_echo "$as_me: error: C++ compiler cannot create executables
3642 < See \`config.log' for more details." >&2;}
3643 <   { (exit 77); exit 77; }; }
3639 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3640 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3641 > { as_fn_set_status 77
3642 > as_fn_error "C++ compiler cannot create executables
3643 > See \`config.log' for more details." "$LINENO" 5; }; }
3644   fi
3610 –
3645   ac_exeext=$ac_cv_exeext
3646  
3647   # Check that the compiler produces executables we can run.  If not, either
3648   # the compiler is broken, or we cross compile.
3649 < { $as_echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
3649 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3650   $as_echo_n "checking whether the C++ compiler works... " >&6; }
3617 – # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3651   # If not cross compiling, check that we can run a simple program.
3652   if test "$cross_compiling" != yes; then
3653    if { ac_try='./$ac_file'
3654 <  { (case "(($ac_try" in
3654 >  { { case "(($ac_try" in
3655    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3656    *) ac_try_echo=$ac_try;;
3657   esac
3658 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3659 < $as_echo "$ac_try_echo") >&5
3658 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3659 > $as_echo "$ac_try_echo"; } >&5
3660    (eval "$ac_try") 2>&5
3661    ac_status=$?
3662 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3663 <  (exit $ac_status); }; }; then
3662 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3663 >  test $ac_status = 0; }; }; then
3664      cross_compiling=no
3665    else
3666      if test "$cross_compiling" = maybe; then
3667          cross_compiling=yes
3668      else
3669 <        { { $as_echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
3669 >        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3670 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3671 > as_fn_error "cannot run C++ compiled programs.
3672   If you meant to cross compile, use \`--host'.
3673 < See \`config.log' for more details." >&5
3639 < $as_echo "$as_me: error: cannot run C++ compiled programs.
3640 < If you meant to cross compile, use \`--host'.
3641 < See \`config.log' for more details." >&2;}
3642 <   { (exit 1); exit 1; }; }
3673 > See \`config.log' for more details." "$LINENO" 5; }
3674      fi
3675    fi
3676   fi
3677 < { $as_echo "$as_me:$LINENO: result: yes" >&5
3677 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3678   $as_echo "yes" >&6; }
3679  
3680 < rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3680 > rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out conftest.out
3681   ac_clean_files=$ac_clean_files_save
3682   # Check that the compiler produces executables we can run.  If not, either
3683   # the compiler is broken, or we cross compile.
3684 < { $as_echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3684 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3685   $as_echo_n "checking whether we are cross compiling... " >&6; }
3686 < { $as_echo "$as_me:$LINENO: result: $cross_compiling" >&5
3686 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3687   $as_echo "$cross_compiling" >&6; }
3688  
3689 < { $as_echo "$as_me:$LINENO: checking for suffix of executables" >&5
3689 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3690   $as_echo_n "checking for suffix of executables... " >&6; }
3691 < if { (ac_try="$ac_link"
3691 > if { { ac_try="$ac_link"
3692   case "(($ac_try" in
3693    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3694    *) ac_try_echo=$ac_try;;
3695   esac
3696 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3697 < $as_echo "$ac_try_echo") >&5
3696 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3697 > $as_echo "$ac_try_echo"; } >&5
3698    (eval "$ac_link") 2>&5
3699    ac_status=$?
3700 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3701 <  (exit $ac_status); }; then
3700 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3701 >  test $ac_status = 0; }; then :
3702    # If both `conftest.exe' and `conftest' are `present' (well, observable)
3703   # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3704   # work properly (i.e., refer to `conftest.exe'), while it won't with
# Line 3682 | Line 3713 | else
3713    esac
3714   done
3715   else
3716 <  { { $as_echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3717 < See \`config.log' for more details." >&5
3718 < $as_echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3719 < See \`config.log' for more details." >&2;}
3689 <   { (exit 1); exit 1; }; }
3716 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3717 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3718 > as_fn_error "cannot compute suffix of executables: cannot compile and link
3719 > See \`config.log' for more details." "$LINENO" 5; }
3720   fi
3691 –
3721   rm -f conftest$ac_cv_exeext
3722 < { $as_echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3722 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3723   $as_echo "$ac_cv_exeext" >&6; }
3724  
3725   rm -f conftest.$ac_ext
3726   EXEEXT=$ac_cv_exeext
3727   ac_exeext=$EXEEXT
3728 < { $as_echo "$as_me:$LINENO: checking for suffix of object files" >&5
3728 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3729   $as_echo_n "checking for suffix of object files... " >&6; }
3730 < if test "${ac_cv_objext+set}" = set; then
3730 > if test "${ac_cv_objext+set}" = set; then :
3731    $as_echo_n "(cached) " >&6
3732   else
3733 <  cat >conftest.$ac_ext <<_ACEOF
3705 < /* confdefs.h.  */
3706 < _ACEOF
3707 < cat confdefs.h >>conftest.$ac_ext
3708 < cat >>conftest.$ac_ext <<_ACEOF
3733 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3734   /* end confdefs.h.  */
3735  
3736   int
# Line 3717 | Line 3742 | rm -f conftest.o conftest.obj
3742   }
3743   _ACEOF
3744   rm -f conftest.o conftest.obj
3745 < if { (ac_try="$ac_compile"
3745 > if { { ac_try="$ac_compile"
3746   case "(($ac_try" in
3747    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3748    *) ac_try_echo=$ac_try;;
3749   esac
3750 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3751 < $as_echo "$ac_try_echo") >&5
3750 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3751 > $as_echo "$ac_try_echo"; } >&5
3752    (eval "$ac_compile") 2>&5
3753    ac_status=$?
3754 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3755 <  (exit $ac_status); }; then
3754 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3755 >  test $ac_status = 0; }; then :
3756    for ac_file in conftest.o conftest.obj conftest.*; do
3757    test -f "$ac_file" || continue;
3758    case $ac_file in
# Line 3740 | Line 3765 | sed 's/^/| /' conftest.$ac_ext >&5
3765    $as_echo "$as_me: failed program was:" >&5
3766   sed 's/^/| /' conftest.$ac_ext >&5
3767  
3768 < { { $as_echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3769 < See \`config.log' for more details." >&5
3770 < $as_echo "$as_me: error: cannot compute suffix of object files: cannot compile
3771 < See \`config.log' for more details." >&2;}
3747 <   { (exit 1); exit 1; }; }
3768 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3769 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3770 > as_fn_error "cannot compute suffix of object files: cannot compile
3771 > See \`config.log' for more details." "$LINENO" 5; }
3772   fi
3749 –
3773   rm -f conftest.$ac_cv_objext conftest.$ac_ext
3774   fi
3775 < { $as_echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3775 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3776   $as_echo "$ac_cv_objext" >&6; }
3777   OBJEXT=$ac_cv_objext
3778   ac_objext=$OBJEXT
3779 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3779 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3780   $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3781 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3781 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
3782    $as_echo_n "(cached) " >&6
3783   else
3784 <  cat >conftest.$ac_ext <<_ACEOF
3762 < /* confdefs.h.  */
3763 < _ACEOF
3764 < cat confdefs.h >>conftest.$ac_ext
3765 < cat >>conftest.$ac_ext <<_ACEOF
3784 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3785   /* end confdefs.h.  */
3786  
3787   int
# Line 3776 | Line 3795 | _ACEOF
3795    return 0;
3796   }
3797   _ACEOF
3798 < rm -f conftest.$ac_objext
3780 < if { (ac_try="$ac_compile"
3781 < case "(($ac_try" in
3782 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3783 <  *) ac_try_echo=$ac_try;;
3784 < esac
3785 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3786 < $as_echo "$ac_try_echo") >&5
3787 <  (eval "$ac_compile") 2>conftest.er1
3788 <  ac_status=$?
3789 <  grep -v '^ *+' conftest.er1 >conftest.err
3790 <  rm -f conftest.er1
3791 <  cat conftest.err >&5
3792 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3793 <  (exit $ac_status); } && {
3794 <         test -z "$ac_cxx_werror_flag" ||
3795 <         test ! -s conftest.err
3796 <       } && test -s conftest.$ac_objext; then
3798 > if ac_fn_cxx_try_compile "$LINENO"; then :
3799    ac_compiler_gnu=yes
3800   else
3801 <  $as_echo "$as_me: failed program was:" >&5
3800 < sed 's/^/| /' conftest.$ac_ext >&5
3801 <
3802 <        ac_compiler_gnu=no
3801 >  ac_compiler_gnu=no
3802   fi
3804 –
3803   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3804   ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3805  
3806   fi
3807 < { $as_echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3807 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3808   $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3809   if test $ac_compiler_gnu = yes; then
3810    GXX=yes
# Line 3815 | Line 3813 | ac_save_CXXFLAGS=$CXXFLAGS
3813   fi
3814   ac_test_CXXFLAGS=${CXXFLAGS+set}
3815   ac_save_CXXFLAGS=$CXXFLAGS
3816 < { $as_echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3816 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3817   $as_echo_n "checking whether $CXX accepts -g... " >&6; }
3818 < if test "${ac_cv_prog_cxx_g+set}" = set; then
3818 > if test "${ac_cv_prog_cxx_g+set}" = set; then :
3819    $as_echo_n "(cached) " >&6
3820   else
3821    ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3822     ac_cxx_werror_flag=yes
3823     ac_cv_prog_cxx_g=no
3824     CXXFLAGS="-g"
3825 <   cat >conftest.$ac_ext <<_ACEOF
3828 < /* confdefs.h.  */
3829 < _ACEOF
3830 < cat confdefs.h >>conftest.$ac_ext
3831 < cat >>conftest.$ac_ext <<_ACEOF
3825 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3826   /* end confdefs.h.  */
3827  
3828   int
# Line 3839 | Line 3833 | _ACEOF
3833    return 0;
3834   }
3835   _ACEOF
3836 < rm -f conftest.$ac_objext
3843 < if { (ac_try="$ac_compile"
3844 < case "(($ac_try" in
3845 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3846 <  *) ac_try_echo=$ac_try;;
3847 < esac
3848 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3849 < $as_echo "$ac_try_echo") >&5
3850 <  (eval "$ac_compile") 2>conftest.er1
3851 <  ac_status=$?
3852 <  grep -v '^ *+' conftest.er1 >conftest.err
3853 <  rm -f conftest.er1
3854 <  cat conftest.err >&5
3855 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3856 <  (exit $ac_status); } && {
3857 <         test -z "$ac_cxx_werror_flag" ||
3858 <         test ! -s conftest.err
3859 <       } && test -s conftest.$ac_objext; then
3836 > if ac_fn_cxx_try_compile "$LINENO"; then :
3837    ac_cv_prog_cxx_g=yes
3838   else
3839 <  $as_echo "$as_me: failed program was:" >&5
3840 < sed 's/^/| /' conftest.$ac_ext >&5
3864 <
3865 <        CXXFLAGS=""
3866 <      cat >conftest.$ac_ext <<_ACEOF
3867 < /* confdefs.h.  */
3868 < _ACEOF
3869 < cat confdefs.h >>conftest.$ac_ext
3870 < cat >>conftest.$ac_ext <<_ACEOF
3839 >  CXXFLAGS=""
3840 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3841   /* end confdefs.h.  */
3842  
3843   int
# Line 3878 | Line 3848 | _ACEOF
3848    return 0;
3849   }
3850   _ACEOF
3851 < rm -f conftest.$ac_objext
3882 < if { (ac_try="$ac_compile"
3883 < case "(($ac_try" in
3884 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3885 <  *) ac_try_echo=$ac_try;;
3886 < esac
3887 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3888 < $as_echo "$ac_try_echo") >&5
3889 <  (eval "$ac_compile") 2>conftest.er1
3890 <  ac_status=$?
3891 <  grep -v '^ *+' conftest.er1 >conftest.err
3892 <  rm -f conftest.er1
3893 <  cat conftest.err >&5
3894 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3895 <  (exit $ac_status); } && {
3896 <         test -z "$ac_cxx_werror_flag" ||
3897 <         test ! -s conftest.err
3898 <       } && test -s conftest.$ac_objext; then
3899 <  :
3900 < else
3901 <  $as_echo "$as_me: failed program was:" >&5
3902 < sed 's/^/| /' conftest.$ac_ext >&5
3851 > if ac_fn_cxx_try_compile "$LINENO"; then :
3852  
3853 <        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3853 > else
3854 >  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3855           CXXFLAGS="-g"
3856 <         cat >conftest.$ac_ext <<_ACEOF
3907 < /* confdefs.h.  */
3908 < _ACEOF
3909 < cat confdefs.h >>conftest.$ac_ext
3910 < cat >>conftest.$ac_ext <<_ACEOF
3856 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3857   /* end confdefs.h.  */
3858  
3859   int
# Line 3918 | Line 3864 | _ACEOF
3864    return 0;
3865   }
3866   _ACEOF
3867 < rm -f conftest.$ac_objext
3922 < if { (ac_try="$ac_compile"
3923 < case "(($ac_try" in
3924 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3925 <  *) ac_try_echo=$ac_try;;
3926 < esac
3927 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3928 < $as_echo "$ac_try_echo") >&5
3929 <  (eval "$ac_compile") 2>conftest.er1
3930 <  ac_status=$?
3931 <  grep -v '^ *+' conftest.er1 >conftest.err
3932 <  rm -f conftest.er1
3933 <  cat conftest.err >&5
3934 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3935 <  (exit $ac_status); } && {
3936 <         test -z "$ac_cxx_werror_flag" ||
3937 <         test ! -s conftest.err
3938 <       } && test -s conftest.$ac_objext; then
3867 > if ac_fn_cxx_try_compile "$LINENO"; then :
3868    ac_cv_prog_cxx_g=yes
3940 – else
3941 –  $as_echo "$as_me: failed program was:" >&5
3942 – sed 's/^/| /' conftest.$ac_ext >&5
3943 –
3944 –
3869   fi
3946 –
3870   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3871   fi
3949 –
3872   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3873   fi
3952 –
3874   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3875     ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3876   fi
3877 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3877 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3878   $as_echo "$ac_cv_prog_cxx_g" >&6; }
3879   if test "$ac_test_CXXFLAGS" = set; then
3880    CXXFLAGS=$ac_save_CXXFLAGS
# Line 3970 | Line 3891 | fi
3891      CXXFLAGS=
3892    fi
3893   fi
3894 < ac_ext=c
3895 < ac_cpp='$CPP $CPPFLAGS'
3896 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3894 > ac_ext=cpp
3895 > ac_cpp='$CXXCPP $CPPFLAGS'
3896 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3899 >
3900 >
3901 >
3902 >
3903 >
3904 >
3905 >
3906 >        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3907 > do
3908 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
3909 > set dummy $ac_prog; ac_word=$2
3910 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3911 > $as_echo_n "checking for $ac_word... " >&6; }
3912 > if test "${ac_cv_prog_MPICXX+set}" = set; then :
3913 >  $as_echo_n "(cached) " >&6
3914 > else
3915 >  if test -n "$MPICXX"; then
3916 >  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3917 > else
3918 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3919 > for as_dir in $PATH
3920 > do
3921 >  IFS=$as_save_IFS
3922 >  test -z "$as_dir" && as_dir=.
3923 >    for ac_exec_ext in '' $ac_executable_extensions; do
3924 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3925 >    ac_cv_prog_MPICXX="$ac_prog"
3926 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3927 >    break 2
3928 >  fi
3929 > done
3930 >  done
3931 > IFS=$as_save_IFS
3932 >
3933 > fi
3934 > fi
3935 > MPICXX=$ac_cv_prog_MPICXX
3936 > if test -n "$MPICXX"; then
3937 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3938 > $as_echo "$MPICXX" >&6; }
3939 > else
3940 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3941 > $as_echo "no" >&6; }
3942 > fi
3943 >
3944 >
3945 >  test -n "$MPICXX" && break
3946 > done
3947 > test -n "$MPICXX" || MPICXX="$CXX"
3948 >
3949 >        ax_mpi_save_CXX="$CXX"
3950 >        CXX="$MPICXX"
3951 >
3952 >
3953 >
3954 > if test x = x"$MPILIBS"; then
3955 >        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3956 > if test "x$ac_cv_func_MPI_Init" = x""yes; then :
3957 >  MPILIBS=" "
3958 > fi
3959  
3960 + fi
3961 +
3962 + if test x = x"$MPILIBS"; then
3963 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3964 + $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3965 + if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
3966 +  $as_echo_n "(cached) " >&6
3967 + else
3968 +  ac_check_lib_save_LIBS=$LIBS
3969 + LIBS="-lmpi  $LIBS"
3970 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3971 + /* end confdefs.h.  */
3972 +
3973 + /* Override any GCC internal prototype to avoid an error.
3974 +   Use char because int might match the return type of a GCC
3975 +   builtin and then its argument prototype would still apply.  */
3976 + #ifdef __cplusplus
3977 + extern "C"
3978 + #endif
3979 + char MPI_Init ();
3980 + int
3981 + main ()
3982 + {
3983 + return MPI_Init ();
3984 +  ;
3985 +  return 0;
3986 + }
3987 + _ACEOF
3988 + if ac_fn_cxx_try_link "$LINENO"; then :
3989 +  ac_cv_lib_mpi_MPI_Init=yes
3990 + else
3991 +  ac_cv_lib_mpi_MPI_Init=no
3992 + fi
3993 + rm -f core conftest.err conftest.$ac_objext \
3994 +    conftest$ac_exeext conftest.$ac_ext
3995 + LIBS=$ac_check_lib_save_LIBS
3996 + fi
3997 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3998 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3999 + if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4000 +  MPILIBS="-lmpi"
4001 + fi
4002 +
4003 + fi
4004 + if test x = x"$MPILIBS"; then
4005 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4006 + $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4007 + if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4008 +  $as_echo_n "(cached) " >&6
4009 + else
4010 +  ac_check_lib_save_LIBS=$LIBS
4011 + LIBS="-lmpich  $LIBS"
4012 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4013 + /* end confdefs.h.  */
4014 +
4015 + /* Override any GCC internal prototype to avoid an error.
4016 +   Use char because int might match the return type of a GCC
4017 +   builtin and then its argument prototype would still apply.  */
4018 + #ifdef __cplusplus
4019 + extern "C"
4020 + #endif
4021 + char MPI_Init ();
4022 + int
4023 + main ()
4024 + {
4025 + return MPI_Init ();
4026 +  ;
4027 +  return 0;
4028 + }
4029 + _ACEOF
4030 + if ac_fn_cxx_try_link "$LINENO"; then :
4031 +  ac_cv_lib_mpich_MPI_Init=yes
4032 + else
4033 +  ac_cv_lib_mpich_MPI_Init=no
4034 + fi
4035 + rm -f core conftest.err conftest.$ac_objext \
4036 +    conftest$ac_exeext conftest.$ac_ext
4037 + LIBS=$ac_check_lib_save_LIBS
4038 + fi
4039 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4040 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4041 + if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4042 +  MPILIBS="-lmpich"
4043 + fi
4044 +
4045 + fi
4046 +
4047 + if test x != x"$MPILIBS"; then
4048 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4049 + $as_echo_n "checking for mpi.h... " >&6; }
4050 +        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4051 + /* end confdefs.h.  */
4052 + #include <mpi.h>
4053 + int
4054 + main ()
4055 + {
4056 +
4057 +  ;
4058 +  return 0;
4059 + }
4060 + _ACEOF
4061 + if ac_fn_cxx_try_compile "$LINENO"; then :
4062 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4063 + $as_echo "yes" >&6; }
4064 + else
4065 +  MPILIBS=""
4066 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4067 + $as_echo "no" >&6; }
4068 + fi
4069 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4070 + fi
4071 +
4072 + CXX="$ax_mpi_save_CXX"
4073 +
4074 +
4075 +
4076 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4077 + if test x = x"$MPILIBS"; then
4078 +        USE_MPI="no"
4079 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. oopse_MPI will not be built." >&5
4080 + $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. oopse_MPI will not be built." >&2;}
4081 +        :
4082 + else
4083 +        USE_MPI="yes"
4084 +        :
4085 + fi
4086 +
4087   ac_ext=c
4088   ac_cpp='$CPP $CPPFLAGS'
4089   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4090   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4091   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4092   if test -n "$ac_tool_prefix"; then
4093 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4093 >  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4094 > set dummy ${ac_tool_prefix}gcc; ac_word=$2
4095 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4096 > $as_echo_n "checking for $ac_word... " >&6; }
4097 > if test "${ac_cv_prog_CC+set}" = set; then :
4098 >  $as_echo_n "(cached) " >&6
4099 > else
4100 >  if test -n "$CC"; then
4101 >  ac_cv_prog_CC="$CC" # Let the user override the test.
4102 > else
4103 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4104 > for as_dir in $PATH
4105 > do
4106 >  IFS=$as_save_IFS
4107 >  test -z "$as_dir" && as_dir=.
4108 >    for ac_exec_ext in '' $ac_executable_extensions; do
4109 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4110 >    ac_cv_prog_CC="${ac_tool_prefix}gcc"
4111 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4112 >    break 2
4113 >  fi
4114 > done
4115 >  done
4116 > IFS=$as_save_IFS
4117 >
4118 > fi
4119 > fi
4120 > CC=$ac_cv_prog_CC
4121 > if test -n "$CC"; then
4122 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4123 > $as_echo "$CC" >&6; }
4124 > else
4125 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4126 > $as_echo "no" >&6; }
4127 > fi
4128 >
4129 >
4130 > fi
4131 > if test -z "$ac_cv_prog_CC"; then
4132 >  ac_ct_CC=$CC
4133 >  # Extract the first word of "gcc", so it can be a program name with args.
4134 > set dummy gcc; ac_word=$2
4135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4136 > $as_echo_n "checking for $ac_word... " >&6; }
4137 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4138 >  $as_echo_n "(cached) " >&6
4139 > else
4140 >  if test -n "$ac_ct_CC"; then
4141 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4142 > else
4143 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4144 > for as_dir in $PATH
4145 > do
4146 >  IFS=$as_save_IFS
4147 >  test -z "$as_dir" && as_dir=.
4148 >    for ac_exec_ext in '' $ac_executable_extensions; do
4149 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4150 >    ac_cv_prog_ac_ct_CC="gcc"
4151 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4152 >    break 2
4153 >  fi
4154 > done
4155 >  done
4156 > IFS=$as_save_IFS
4157 >
4158 > fi
4159 > fi
4160 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
4161 > if test -n "$ac_ct_CC"; then
4162 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4163 > $as_echo "$ac_ct_CC" >&6; }
4164 > else
4165 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4166 > $as_echo "no" >&6; }
4167 > fi
4168 >
4169 >  if test "x$ac_ct_CC" = x; then
4170 >    CC=""
4171 >  else
4172 >    case $cross_compiling:$ac_tool_warned in
4173 > yes:)
4174 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4175 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4176 > ac_tool_warned=yes ;;
4177 > esac
4178 >    CC=$ac_ct_CC
4179 >  fi
4180 > else
4181 >  CC="$ac_cv_prog_CC"
4182 > fi
4183 >
4184 > if test -z "$CC"; then
4185 >          if test -n "$ac_tool_prefix"; then
4186 >    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4187 > set dummy ${ac_tool_prefix}cc; ac_word=$2
4188 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4189 > $as_echo_n "checking for $ac_word... " >&6; }
4190 > if test "${ac_cv_prog_CC+set}" = set; then :
4191 >  $as_echo_n "(cached) " >&6
4192 > else
4193 >  if test -n "$CC"; then
4194 >  ac_cv_prog_CC="$CC" # Let the user override the test.
4195 > else
4196 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4197 > for as_dir in $PATH
4198 > do
4199 >  IFS=$as_save_IFS
4200 >  test -z "$as_dir" && as_dir=.
4201 >    for ac_exec_ext in '' $ac_executable_extensions; do
4202 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4203 >    ac_cv_prog_CC="${ac_tool_prefix}cc"
4204 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4205 >    break 2
4206 >  fi
4207 > done
4208 >  done
4209 > IFS=$as_save_IFS
4210 >
4211 > fi
4212 > fi
4213 > CC=$ac_cv_prog_CC
4214 > if test -n "$CC"; then
4215 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4216 > $as_echo "$CC" >&6; }
4217 > else
4218 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4219 > $as_echo "no" >&6; }
4220 > fi
4221 >
4222 >
4223 >  fi
4224 > fi
4225 > if test -z "$CC"; then
4226 >  # Extract the first word of "cc", so it can be a program name with args.
4227 > set dummy cc; ac_word=$2
4228 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4229 > $as_echo_n "checking for $ac_word... " >&6; }
4230 > if test "${ac_cv_prog_CC+set}" = set; then :
4231 >  $as_echo_n "(cached) " >&6
4232 > else
4233 >  if test -n "$CC"; then
4234 >  ac_cv_prog_CC="$CC" # Let the user override the test.
4235 > else
4236 >  ac_prog_rejected=no
4237 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4238 > for as_dir in $PATH
4239 > do
4240 >  IFS=$as_save_IFS
4241 >  test -z "$as_dir" && as_dir=.
4242 >    for ac_exec_ext in '' $ac_executable_extensions; do
4243 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4244 >    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4245 >       ac_prog_rejected=yes
4246 >       continue
4247 >     fi
4248 >    ac_cv_prog_CC="cc"
4249 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4250 >    break 2
4251 >  fi
4252 > done
4253 >  done
4254 > IFS=$as_save_IFS
4255 >
4256 > if test $ac_prog_rejected = yes; then
4257 >  # We found a bogon in the path, so make sure we never use it.
4258 >  set dummy $ac_cv_prog_CC
4259 >  shift
4260 >  if test $# != 0; then
4261 >    # We chose a different compiler from the bogus one.
4262 >    # However, it has the same basename, so the bogon will be chosen
4263 >    # first if we set CC to just the basename; use the full file name.
4264 >    shift
4265 >    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4266 >  fi
4267 > fi
4268 > fi
4269 > fi
4270 > CC=$ac_cv_prog_CC
4271 > if test -n "$CC"; then
4272 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4273 > $as_echo "$CC" >&6; }
4274 > else
4275 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4276 > $as_echo "no" >&6; }
4277 > fi
4278 >
4279 >
4280 > fi
4281 > if test -z "$CC"; then
4282 >  if test -n "$ac_tool_prefix"; then
4283 >  for ac_prog in cl.exe
4284    do
4285      # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4286   set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4287 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4287 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4288   $as_echo_n "checking for $ac_word... " >&6; }
4289 < if test "${ac_cv_prog_CC+set}" = set; then
4289 > if test "${ac_cv_prog_CC+set}" = set; then :
4290    $as_echo_n "(cached) " >&6
4291   else
4292    if test -n "$CC"; then
# Line 3999 | Line 4297 | do
4297   do
4298    IFS=$as_save_IFS
4299    test -z "$as_dir" && as_dir=.
4300 <  for ac_exec_ext in '' $ac_executable_extensions; do
4300 >    for ac_exec_ext in '' $ac_executable_extensions; do
4301    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4302      ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4303 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4303 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4304      break 2
4305    fi
4306   done
4307 < done
4307 >  done
4308   IFS=$as_save_IFS
4309  
4310   fi
4311   fi
4312   CC=$ac_cv_prog_CC
4313   if test -n "$CC"; then
4314 <  { $as_echo "$as_me:$LINENO: result: $CC" >&5
4314 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
4315   $as_echo "$CC" >&6; }
4316   else
4317 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4317 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4318   $as_echo "no" >&6; }
4319   fi
4320  
# Line 4026 | Line 4324 | if test -z "$CC"; then
4324   fi
4325   if test -z "$CC"; then
4326    ac_ct_CC=$CC
4327 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4327 >  for ac_prog in cl.exe
4328   do
4329    # Extract the first word of "$ac_prog", so it can be a program name with args.
4330   set dummy $ac_prog; ac_word=$2
4331 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4331 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4332   $as_echo_n "checking for $ac_word... " >&6; }
4333 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4333 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
4334    $as_echo_n "(cached) " >&6
4335   else
4336    if test -n "$ac_ct_CC"; then
# Line 4043 | Line 4341 | do
4341   do
4342    IFS=$as_save_IFS
4343    test -z "$as_dir" && as_dir=.
4344 <  for ac_exec_ext in '' $ac_executable_extensions; do
4344 >    for ac_exec_ext in '' $ac_executable_extensions; do
4345    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4346      ac_cv_prog_ac_ct_CC="$ac_prog"
4347 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4347 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4348      break 2
4349    fi
4350   done
4351 < done
4351 >  done
4352   IFS=$as_save_IFS
4353  
4354   fi
4355   fi
4356   ac_ct_CC=$ac_cv_prog_ac_ct_CC
4357   if test -n "$ac_ct_CC"; then
4358 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4358 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
4359   $as_echo "$ac_ct_CC" >&6; }
4360   else
4361 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4361 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4362   $as_echo "no" >&6; }
4363   fi
4364  
# Line 4073 | Line 4371 | yes:)
4371    else
4372      case $cross_compiling:$ac_tool_warned in
4373   yes:)
4374 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4375 < whose name does not start with the host triplet.  If you think this
4078 < configuration is useful to you, please write to autoconf@gnu.org." >&5
4079 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
4080 < whose name does not start with the host triplet.  If you think this
4081 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4374 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4375 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4376   ac_tool_warned=yes ;;
4377   esac
4378      CC=$ac_ct_CC
4379    fi
4380   fi
4381  
4382 + fi
4383  
4089 – test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
4090 – See \`config.log' for more details." >&5
4091 – $as_echo "$as_me: error: no acceptable C compiler found in \$PATH
4092 – See \`config.log' for more details." >&2;}
4093 –   { (exit 1); exit 1; }; }
4384  
4385 + test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4386 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4387 + as_fn_error "no acceptable C compiler found in \$PATH
4388 + See \`config.log' for more details." "$LINENO" 5; }
4389 +
4390   # Provide some information about the compiler.
4391 < $as_echo "$as_me:$LINENO: checking for C compiler version" >&5
4391 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
4392   set X $ac_compile
4393   ac_compiler=$2
4394 < { (ac_try="$ac_compiler --version >&5"
4394 > for ac_option in --version -v -V -qversion; do
4395 >  { { ac_try="$ac_compiler $ac_option >&5"
4396   case "(($ac_try" in
4397    *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4398    *) ac_try_echo=$ac_try;;
4399   esac
4400 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4401 < $as_echo "$ac_try_echo") >&5
4402 <  (eval "$ac_compiler --version >&5") 2>&5
4400 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4401 > $as_echo "$ac_try_echo"; } >&5
4402 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
4403    ac_status=$?
4404 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4405 <  (exit $ac_status); }
4406 < { (ac_try="$ac_compiler -v >&5"
4407 < case "(($ac_try" in
4408 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4409 <  *) ac_try_echo=$ac_try;;
4410 < esac
4411 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4412 < $as_echo "$ac_try_echo") >&5
4413 <  (eval "$ac_compiler -v >&5") 2>&5
4118 <  ac_status=$?
4119 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4120 <  (exit $ac_status); }
4121 < { (ac_try="$ac_compiler -V >&5"
4122 < case "(($ac_try" in
4123 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4124 <  *) ac_try_echo=$ac_try;;
4125 < esac
4126 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4127 < $as_echo "$ac_try_echo") >&5
4128 <  (eval "$ac_compiler -V >&5") 2>&5
4129 <  ac_status=$?
4130 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4131 <  (exit $ac_status); }
4404 >  if test -s conftest.err; then
4405 >    sed '10a\
4406 > ... rest of stderr output deleted ...
4407 >         10q' conftest.err >conftest.er1
4408 >    cat conftest.er1 >&5
4409 >    rm -f conftest.er1 conftest.err
4410 >  fi
4411 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4412 >  test $ac_status = 0; }
4413 > done
4414  
4415 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
4415 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
4416   $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4417 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
4417 > if test "${ac_cv_c_compiler_gnu+set}" = set; then :
4418    $as_echo_n "(cached) " >&6
4419   else
4420 <  cat >conftest.$ac_ext <<_ACEOF
4139 < /* confdefs.h.  */
4140 < _ACEOF
4141 < cat confdefs.h >>conftest.$ac_ext
4142 < cat >>conftest.$ac_ext <<_ACEOF
4420 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4421   /* end confdefs.h.  */
4422  
4423   int
# Line 4153 | Line 4431 | _ACEOF
4431    return 0;
4432   }
4433   _ACEOF
4434 < rm -f conftest.$ac_objext
4157 < if { (ac_try="$ac_compile"
4158 < case "(($ac_try" in
4159 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4160 <  *) ac_try_echo=$ac_try;;
4161 < esac
4162 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4163 < $as_echo "$ac_try_echo") >&5
4164 <  (eval "$ac_compile") 2>conftest.er1
4165 <  ac_status=$?
4166 <  grep -v '^ *+' conftest.er1 >conftest.err
4167 <  rm -f conftest.er1
4168 <  cat conftest.err >&5
4169 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4170 <  (exit $ac_status); } && {
4171 <         test -z "$ac_c_werror_flag" ||
4172 <         test ! -s conftest.err
4173 <       } && test -s conftest.$ac_objext; then
4434 > if ac_fn_c_try_compile "$LINENO"; then :
4435    ac_compiler_gnu=yes
4436   else
4437 <  $as_echo "$as_me: failed program was:" >&5
4177 < sed 's/^/| /' conftest.$ac_ext >&5
4178 <
4179 <        ac_compiler_gnu=no
4437 >  ac_compiler_gnu=no
4438   fi
4181 –
4439   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4440   ac_cv_c_compiler_gnu=$ac_compiler_gnu
4441  
4442   fi
4443 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
4443 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
4444   $as_echo "$ac_cv_c_compiler_gnu" >&6; }
4445   if test $ac_compiler_gnu = yes; then
4446    GCC=yes
# Line 4192 | Line 4449 | ac_save_CFLAGS=$CFLAGS
4449   fi
4450   ac_test_CFLAGS=${CFLAGS+set}
4451   ac_save_CFLAGS=$CFLAGS
4452 < { $as_echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
4452 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
4453   $as_echo_n "checking whether $CC accepts -g... " >&6; }
4454 < if test "${ac_cv_prog_cc_g+set}" = set; then
4454 > if test "${ac_cv_prog_cc_g+set}" = set; then :
4455    $as_echo_n "(cached) " >&6
4456   else
4457    ac_save_c_werror_flag=$ac_c_werror_flag
4458     ac_c_werror_flag=yes
4459     ac_cv_prog_cc_g=no
4460     CFLAGS="-g"
4461 <   cat >conftest.$ac_ext <<_ACEOF
4205 < /* confdefs.h.  */
4206 < _ACEOF
4207 < cat confdefs.h >>conftest.$ac_ext
4208 < cat >>conftest.$ac_ext <<_ACEOF
4461 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4462   /* end confdefs.h.  */
4463  
4464   int
# Line 4216 | Line 4469 | _ACEOF
4469    return 0;
4470   }
4471   _ACEOF
4472 < rm -f conftest.$ac_objext
4220 < if { (ac_try="$ac_compile"
4221 < case "(($ac_try" in
4222 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4223 <  *) ac_try_echo=$ac_try;;
4224 < esac
4225 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4226 < $as_echo "$ac_try_echo") >&5
4227 <  (eval "$ac_compile") 2>conftest.er1
4228 <  ac_status=$?
4229 <  grep -v '^ *+' conftest.er1 >conftest.err
4230 <  rm -f conftest.er1
4231 <  cat conftest.err >&5
4232 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4233 <  (exit $ac_status); } && {
4234 <         test -z "$ac_c_werror_flag" ||
4235 <         test ! -s conftest.err
4236 <       } && test -s conftest.$ac_objext; then
4472 > if ac_fn_c_try_compile "$LINENO"; then :
4473    ac_cv_prog_cc_g=yes
4474   else
4475 <  $as_echo "$as_me: failed program was:" >&5
4476 < sed 's/^/| /' conftest.$ac_ext >&5
4241 <
4242 <        CFLAGS=""
4243 <      cat >conftest.$ac_ext <<_ACEOF
4244 < /* confdefs.h.  */
4245 < _ACEOF
4246 < cat confdefs.h >>conftest.$ac_ext
4247 < cat >>conftest.$ac_ext <<_ACEOF
4475 >  CFLAGS=""
4476 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4477   /* end confdefs.h.  */
4478  
4479   int
# Line 4255 | Line 4484 | _ACEOF
4484    return 0;
4485   }
4486   _ACEOF
4487 < rm -f conftest.$ac_objext
4259 < if { (ac_try="$ac_compile"
4260 < case "(($ac_try" in
4261 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4262 <  *) ac_try_echo=$ac_try;;
4263 < esac
4264 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4265 < $as_echo "$ac_try_echo") >&5
4266 <  (eval "$ac_compile") 2>conftest.er1
4267 <  ac_status=$?
4268 <  grep -v '^ *+' conftest.er1 >conftest.err
4269 <  rm -f conftest.er1
4270 <  cat conftest.err >&5
4271 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4272 <  (exit $ac_status); } && {
4273 <         test -z "$ac_c_werror_flag" ||
4274 <         test ! -s conftest.err
4275 <       } && test -s conftest.$ac_objext; then
4276 <  :
4277 < else
4278 <  $as_echo "$as_me: failed program was:" >&5
4279 < sed 's/^/| /' conftest.$ac_ext >&5
4487 > if ac_fn_c_try_compile "$LINENO"; then :
4488  
4489 <        ac_c_werror_flag=$ac_save_c_werror_flag
4489 > else
4490 >  ac_c_werror_flag=$ac_save_c_werror_flag
4491           CFLAGS="-g"
4492 <         cat >conftest.$ac_ext <<_ACEOF
4284 < /* confdefs.h.  */
4285 < _ACEOF
4286 < cat confdefs.h >>conftest.$ac_ext
4287 < cat >>conftest.$ac_ext <<_ACEOF
4492 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4493   /* end confdefs.h.  */
4494  
4495   int
# Line 4295 | Line 4500 | _ACEOF
4500    return 0;
4501   }
4502   _ACEOF
4503 < rm -f conftest.$ac_objext
4299 < if { (ac_try="$ac_compile"
4300 < case "(($ac_try" in
4301 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4302 <  *) ac_try_echo=$ac_try;;
4303 < esac
4304 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4305 < $as_echo "$ac_try_echo") >&5
4306 <  (eval "$ac_compile") 2>conftest.er1
4307 <  ac_status=$?
4308 <  grep -v '^ *+' conftest.er1 >conftest.err
4309 <  rm -f conftest.er1
4310 <  cat conftest.err >&5
4311 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4312 <  (exit $ac_status); } && {
4313 <         test -z "$ac_c_werror_flag" ||
4314 <         test ! -s conftest.err
4315 <       } && test -s conftest.$ac_objext; then
4503 > if ac_fn_c_try_compile "$LINENO"; then :
4504    ac_cv_prog_cc_g=yes
4317 – else
4318 –  $as_echo "$as_me: failed program was:" >&5
4319 – sed 's/^/| /' conftest.$ac_ext >&5
4320 –
4321 –
4505   fi
4323 –
4506   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4507   fi
4326 –
4508   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4509   fi
4329 –
4510   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4511     ac_c_werror_flag=$ac_save_c_werror_flag
4512   fi
4513 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
4513 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
4514   $as_echo "$ac_cv_prog_cc_g" >&6; }
4515   if test "$ac_test_CFLAGS" = set; then
4516    CFLAGS=$ac_save_CFLAGS
# Line 4347 | Line 4527 | fi
4527      CFLAGS=
4528    fi
4529   fi
4530 < { $as_echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
4530 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
4531   $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
4532 < if test "${ac_cv_prog_cc_c89+set}" = set; then
4532 > if test "${ac_cv_prog_cc_c89+set}" = set; then :
4533    $as_echo_n "(cached) " >&6
4534   else
4535    ac_cv_prog_cc_c89=no
4536   ac_save_CC=$CC
4537 < cat >conftest.$ac_ext <<_ACEOF
4358 < /* confdefs.h.  */
4359 < _ACEOF
4360 < cat confdefs.h >>conftest.$ac_ext
4361 < cat >>conftest.$ac_ext <<_ACEOF
4537 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4538   /* end confdefs.h.  */
4539   #include <stdarg.h>
4540   #include <stdio.h>
# Line 4415 | Line 4591 | do
4591          -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4592   do
4593    CC="$ac_save_CC $ac_arg"
4594 <  rm -f conftest.$ac_objext
4419 < if { (ac_try="$ac_compile"
4420 < case "(($ac_try" in
4421 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4422 <  *) ac_try_echo=$ac_try;;
4423 < esac
4424 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4425 < $as_echo "$ac_try_echo") >&5
4426 <  (eval "$ac_compile") 2>conftest.er1
4427 <  ac_status=$?
4428 <  grep -v '^ *+' conftest.er1 >conftest.err
4429 <  rm -f conftest.er1
4430 <  cat conftest.err >&5
4431 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4432 <  (exit $ac_status); } && {
4433 <         test -z "$ac_c_werror_flag" ||
4434 <         test ! -s conftest.err
4435 <       } && test -s conftest.$ac_objext; then
4594 >  if ac_fn_c_try_compile "$LINENO"; then :
4595    ac_cv_prog_cc_c89=$ac_arg
4437 – else
4438 –  $as_echo "$as_me: failed program was:" >&5
4439 – sed 's/^/| /' conftest.$ac_ext >&5
4440 –
4441 –
4596   fi
4443 –
4597   rm -f core conftest.err conftest.$ac_objext
4598    test "x$ac_cv_prog_cc_c89" != "xno" && break
4599   done
# Line 4451 | Line 4604 | case "x$ac_cv_prog_cc_c89" in
4604   # AC_CACHE_VAL
4605   case "x$ac_cv_prog_cc_c89" in
4606    x)
4607 <    { $as_echo "$as_me:$LINENO: result: none needed" >&5
4607 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
4608   $as_echo "none needed" >&6; } ;;
4609    xno)
4610 <    { $as_echo "$as_me:$LINENO: result: unsupported" >&5
4610 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
4611   $as_echo "unsupported" >&6; } ;;
4612    *)
4613      CC="$CC $ac_cv_prog_cc_c89"
4614 <    { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
4614 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
4615   $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4616   esac
4617 + if test "x$ac_cv_prog_cc_c89" != xno; then :
4618  
4619 + fi
4620  
4621   ac_ext=c
4622   ac_cpp='$CPP $CPPFLAGS'
# Line 4469 | Line 4624 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
4624   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4625   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4626  
4472 – ac_ext=${ac_fc_srcext-f}
4473 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4474 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4475 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4476 – if test -n "$ac_tool_prefix"; then
4477 –  for ac_prog in $FC $ac_cv_prog_acx_mpi_mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
4478 –  do
4479 –    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4480 – set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4481 – { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4482 – $as_echo_n "checking for $ac_word... " >&6; }
4483 – if test "${ac_cv_prog_FC+set}" = set; then
4484 –  $as_echo_n "(cached) " >&6
4485 – else
4486 –  if test -n "$FC"; then
4487 –  ac_cv_prog_FC="$FC" # Let the user override the test.
4488 – else
4489 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4490 – for as_dir in $PATH
4491 – do
4492 –  IFS=$as_save_IFS
4493 –  test -z "$as_dir" && as_dir=.
4494 –  for ac_exec_ext in '' $ac_executable_extensions; do
4495 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4496 –    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4497 –    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4498 –    break 2
4499 –  fi
4500 – done
4501 – done
4502 – IFS=$as_save_IFS
4627  
4628 < fi
4505 < fi
4506 < FC=$ac_cv_prog_FC
4507 < if test -n "$FC"; then
4508 <  { $as_echo "$as_me:$LINENO: result: $FC" >&5
4509 < $as_echo "$FC" >&6; }
4510 < else
4511 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4512 < $as_echo "no" >&6; }
4513 < fi
4628 > if test $USE_MPI != no; then :
4629  
4630 + ac_ext=c
4631 + ac_cpp='$CPP $CPPFLAGS'
4632 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4633 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4634 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
4635  
4636 <    test -n "$FC" && break
4637 <  done
4638 < fi
4639 < if test -z "$FC"; then
4640 <  ac_ct_FC=$FC
4641 <  for ac_prog in $FC $ac_cv_prog_acx_mpi_mpif90 ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
4636 >
4637 >
4638 >
4639 >
4640 >
4641 >        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4642   do
4643    # Extract the first word of "$ac_prog", so it can be a program name with args.
4644   set dummy $ac_prog; ac_word=$2
4645 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4645 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4646   $as_echo_n "checking for $ac_word... " >&6; }
4647 < if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4647 > if test "${ac_cv_prog_MPICC+set}" = set; then :
4648    $as_echo_n "(cached) " >&6
4649   else
4650 <  if test -n "$ac_ct_FC"; then
4651 <  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4650 >  if test -n "$MPICC"; then
4651 >  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4652   else
4653   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4654   for as_dir in $PATH
4655   do
4656    IFS=$as_save_IFS
4657    test -z "$as_dir" && as_dir=.
4658 <  for ac_exec_ext in '' $ac_executable_extensions; do
4658 >    for ac_exec_ext in '' $ac_executable_extensions; do
4659    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4660 <    ac_cv_prog_ac_ct_FC="$ac_prog"
4661 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4660 >    ac_cv_prog_MPICC="$ac_prog"
4661 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4662      break 2
4663    fi
4664   done
4665 < done
4665 >  done
4666   IFS=$as_save_IFS
4667  
4668   fi
4669   fi
4670 < ac_ct_FC=$ac_cv_prog_ac_ct_FC
4671 < if test -n "$ac_ct_FC"; then
4672 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4673 < $as_echo "$ac_ct_FC" >&6; }
4670 > MPICC=$ac_cv_prog_MPICC
4671 > if test -n "$MPICC"; then
4672 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4673 > $as_echo "$MPICC" >&6; }
4674   else
4675 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4675 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4676   $as_echo "no" >&6; }
4677   fi
4678  
4679  
4680 <  test -n "$ac_ct_FC" && break
4680 >  test -n "$MPICC" && break
4681   done
4682 + test -n "$MPICC" || MPICC="$CC"
4683  
4684 <  if test "x$ac_ct_FC" = x; then
4685 <    FC=""
4565 <  else
4566 <    case $cross_compiling:$ac_tool_warned in
4567 < yes:)
4568 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4569 < whose name does not start with the host triplet.  If you think this
4570 < configuration is useful to you, please write to autoconf@gnu.org." >&5
4571 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
4572 < whose name does not start with the host triplet.  If you think this
4573 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4574 < ac_tool_warned=yes ;;
4575 < esac
4576 <    FC=$ac_ct_FC
4577 <  fi
4578 < fi
4684 >        ax_mpi_save_CC="$CC"
4685 >        CC="$MPICC"
4686  
4687  
4581 – # Provide some information about the compiler.
4582 – $as_echo "$as_me:$LINENO: checking for Fortran compiler version" >&5
4583 – set X $ac_compile
4584 – ac_compiler=$2
4585 – { (ac_try="$ac_compiler --version >&5"
4586 – case "(($ac_try" in
4587 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4588 –  *) ac_try_echo=$ac_try;;
4589 – esac
4590 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4591 – $as_echo "$ac_try_echo") >&5
4592 –  (eval "$ac_compiler --version >&5") 2>&5
4593 –  ac_status=$?
4594 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4595 –  (exit $ac_status); }
4596 – { (ac_try="$ac_compiler -v >&5"
4597 – case "(($ac_try" in
4598 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4599 –  *) ac_try_echo=$ac_try;;
4600 – esac
4601 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4602 – $as_echo "$ac_try_echo") >&5
4603 –  (eval "$ac_compiler -v >&5") 2>&5
4604 –  ac_status=$?
4605 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4606 –  (exit $ac_status); }
4607 – { (ac_try="$ac_compiler -V >&5"
4608 – case "(($ac_try" in
4609 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4610 –  *) ac_try_echo=$ac_try;;
4611 – esac
4612 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4613 – $as_echo "$ac_try_echo") >&5
4614 –  (eval "$ac_compiler -V >&5") 2>&5
4615 –  ac_status=$?
4616 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4617 –  (exit $ac_status); }
4618 – rm -f a.out
4688  
4689 < # If we don't use `.F' as extension, the preprocessor is not run on the
4690 < # input file.  (Note that this only needs to work for GNU compilers.)
4691 < ac_save_ext=$ac_ext
4692 < ac_ext=F
4693 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4694 < $as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4695 < if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4689 > if test x = x"$MPILIBS"; then
4690 >        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4691 > if test "x$ac_cv_func_MPI_Init" = x""yes; then :
4692 >  MPILIBS=" "
4693 > fi
4694 >
4695 > fi
4696 >
4697 > if test x = x"$MPILIBS"; then
4698 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4699 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4700 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
4701    $as_echo_n "(cached) " >&6
4702   else
4703 <  cat >conftest.$ac_ext <<_ACEOF
4704 <      program main
4705 < #ifndef __GNUC__
4706 <       choke me
4707 < #endif
4708 <
4709 <      end
4710 < _ACEOF
4711 < rm -f conftest.$ac_objext
4712 < if { (ac_try="$ac_compile"
4713 < case "(($ac_try" in
4714 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4715 <  *) ac_try_echo=$ac_try;;
4716 < esac
4717 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4718 < $as_echo "$ac_try_echo") >&5
4719 <  (eval "$ac_compile") 2>conftest.er1
4720 <  ac_status=$?
4721 <  grep -v '^ *+' conftest.er1 >conftest.err
4722 <  rm -f conftest.er1
4723 <  cat conftest.err >&5
4724 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4725 <  (exit $ac_status); } && {
4726 <         test -z "$ac_fc_werror_flag" ||
4727 <         test ! -s conftest.err
4728 <       } && test -s conftest.$ac_objext; then
4729 <  ac_compiler_gnu=yes
4730 < else
4731 <  $as_echo "$as_me: failed program was:" >&5
4732 < sed 's/^/| /' conftest.$ac_ext >&5
4733 <
4734 <        ac_compiler_gnu=no
4735 < fi
4736 <
4737 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4738 < ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4739 <
4740 < fi
4741 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4742 < $as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4743 < ac_ext=$ac_save_ext
4744 < ac_test_FFLAGS=${FCFLAGS+set}
4745 < ac_save_FFLAGS=$FCFLAGS
4746 < FCFLAGS=
4747 < { $as_echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4748 < $as_echo_n "checking whether $FC accepts -g... " >&6; }
4749 < if test "${ac_cv_prog_fc_g+set}" = set; then
4750 <  $as_echo_n "(cached) " >&6
4751 < else
4752 <  FCFLAGS=-g
4753 < cat >conftest.$ac_ext <<_ACEOF
4754 <      program main
4755 <
4756 <      end
4757 < _ACEOF
4758 < rm -f conftest.$ac_objext
4759 < if { (ac_try="$ac_compile"
4760 < case "(($ac_try" in
4761 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4762 <  *) ac_try_echo=$ac_try;;
4763 < esac
4764 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4765 < $as_echo "$ac_try_echo") >&5
4766 <  (eval "$ac_compile") 2>conftest.er1
4767 <  ac_status=$?
4768 <  grep -v '^ *+' conftest.er1 >conftest.err
4769 <  rm -f conftest.er1
4770 <  cat conftest.err >&5
4771 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4772 <  (exit $ac_status); } && {
4773 <         test -z "$ac_fc_werror_flag" ||
4774 <         test ! -s conftest.err
4775 <       } && test -s conftest.$ac_objext; then
4776 <  ac_cv_prog_fc_g=yes
4777 < else
4778 <  $as_echo "$as_me: failed program was:" >&5
4779 < sed 's/^/| /' conftest.$ac_ext >&5
4780 <
4781 <        ac_cv_prog_fc_g=no
4782 < fi
4783 <
4784 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4785 <
4786 < fi
4787 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4788 < $as_echo "$ac_cv_prog_fc_g" >&6; }
4789 < if test "$ac_test_FFLAGS" = set; then
4790 <  FCFLAGS=$ac_save_FFLAGS
4791 < elif test $ac_cv_prog_fc_g = yes; then
4792 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4793 <    FCFLAGS="-g -O2"
4794 <  else
4795 <    FCFLAGS="-g"
4796 <  fi
4797 < else
4798 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4799 <    FCFLAGS="-O2"
4800 <  else
4801 <    FCFLAGS=
4802 <  fi
4803 < fi
4804 <
4805 < ac_ext=c
4806 < ac_cpp='$CPP $CPPFLAGS'
4807 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4808 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4809 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4810 <
4811 < ac_ext=c
4812 < ac_cpp='$CPP $CPPFLAGS'
4813 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4814 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4815 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4816 < { $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4817 < $as_echo_n "checking how to run the C preprocessor... " >&6; }
4818 < # On Suns, sometimes $CPP names a directory.
4819 < if test -n "$CPP" && test -d "$CPP"; then
4820 <  CPP=
4821 < fi
4822 < if test -z "$CPP"; then
4823 <  if test "${ac_cv_prog_CPP+set}" = set; then
4824 <  $as_echo_n "(cached) " >&6
4825 < else
4826 <      # Double quotes because CPP needs to be expanded
4827 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4828 <    do
4829 <      ac_preproc_ok=false
4830 < for ac_c_preproc_warn_flag in '' yes
4831 < do
4832 <  # Use a header file that comes with gcc, so configuring glibc
4833 <  # with a fresh cross-compiler works.
4834 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4835 <  # <limits.h> exists even on freestanding compilers.
4836 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4837 <  # not just through cpp. "Syntax error" is here to catch this case.
4838 <  cat >conftest.$ac_ext <<_ACEOF
4839 < /* confdefs.h.  */
4840 < _ACEOF
4841 < cat confdefs.h >>conftest.$ac_ext
4842 < cat >>conftest.$ac_ext <<_ACEOF
4843 < /* end confdefs.h.  */
4844 < #ifdef __STDC__
4845 < # include <limits.h>
4846 < #else
4847 < # include <assert.h>
4848 < #endif
4849 <                     Syntax error
4850 < _ACEOF
4851 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4852 < case "(($ac_try" in
4853 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4854 <  *) ac_try_echo=$ac_try;;
4855 < esac
4856 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4857 < $as_echo "$ac_try_echo") >&5
4858 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4859 <  ac_status=$?
4860 <  grep -v '^ *+' conftest.er1 >conftest.err
4861 <  rm -f conftest.er1
4862 <  cat conftest.err >&5
4863 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4864 <  (exit $ac_status); } >/dev/null && {
4865 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4866 <         test ! -s conftest.err
4867 <       }; then
4868 <  :
4869 < else
4870 <  $as_echo "$as_me: failed program was:" >&5
4871 < sed 's/^/| /' conftest.$ac_ext >&5
4872 <
4873 <  # Broken: fails on valid input.
4874 < continue
4875 < fi
4876 <
4877 < rm -f conftest.err conftest.$ac_ext
4878 <
4879 <  # OK, works on sane cases.  Now check whether nonexistent headers
4880 <  # can be detected and how.
4881 <  cat >conftest.$ac_ext <<_ACEOF
4882 < /* confdefs.h.  */
4883 < _ACEOF
4884 < cat confdefs.h >>conftest.$ac_ext
4885 < cat >>conftest.$ac_ext <<_ACEOF
4886 < /* end confdefs.h.  */
4887 < #include <ac_nonexistent.h>
4888 < _ACEOF
4889 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4890 < case "(($ac_try" in
4891 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4892 <  *) ac_try_echo=$ac_try;;
4893 < esac
4894 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4895 < $as_echo "$ac_try_echo") >&5
4896 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4897 <  ac_status=$?
4898 <  grep -v '^ *+' conftest.er1 >conftest.err
4899 <  rm -f conftest.er1
4900 <  cat conftest.err >&5
4901 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4902 <  (exit $ac_status); } >/dev/null && {
4903 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4904 <         test ! -s conftest.err
4905 <       }; then
4906 <  # Broken: success on invalid input.
4907 < continue
4908 < else
4909 <  $as_echo "$as_me: failed program was:" >&5
4910 < sed 's/^/| /' conftest.$ac_ext >&5
4911 <
4912 <  # Passes both tests.
4913 < ac_preproc_ok=:
4914 < break
4915 < fi
4916 <
4917 < rm -f conftest.err conftest.$ac_ext
4918 <
4919 < done
4920 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4921 < rm -f conftest.err conftest.$ac_ext
4922 < if $ac_preproc_ok; then
4923 <  break
4924 < fi
4925 <
4926 <    done
4927 <    ac_cv_prog_CPP=$CPP
4928 <
4929 < fi
4930 <  CPP=$ac_cv_prog_CPP
4931 < else
4932 <  ac_cv_prog_CPP=$CPP
4933 < fi
4934 < { $as_echo "$as_me:$LINENO: result: $CPP" >&5
4935 < $as_echo "$CPP" >&6; }
4936 < ac_preproc_ok=false
4937 < for ac_c_preproc_warn_flag in '' yes
4938 < do
4939 <  # Use a header file that comes with gcc, so configuring glibc
4940 <  # with a fresh cross-compiler works.
4941 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4942 <  # <limits.h> exists even on freestanding compilers.
4943 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4944 <  # not just through cpp. "Syntax error" is here to catch this case.
4945 <  cat >conftest.$ac_ext <<_ACEOF
4946 < /* confdefs.h.  */
4947 < _ACEOF
4948 < cat confdefs.h >>conftest.$ac_ext
4949 < cat >>conftest.$ac_ext <<_ACEOF
4950 < /* end confdefs.h.  */
4951 < #ifdef __STDC__
4952 < # include <limits.h>
4953 < #else
4954 < # include <assert.h>
4955 < #endif
4956 <                     Syntax error
4957 < _ACEOF
4958 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4959 < case "(($ac_try" in
4960 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4961 <  *) ac_try_echo=$ac_try;;
4962 < esac
4963 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4964 < $as_echo "$ac_try_echo") >&5
4965 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4966 <  ac_status=$?
4967 <  grep -v '^ *+' conftest.er1 >conftest.err
4968 <  rm -f conftest.er1
4969 <  cat conftest.err >&5
4970 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4971 <  (exit $ac_status); } >/dev/null && {
4972 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4973 <         test ! -s conftest.err
4974 <       }; then
4975 <  :
4976 < else
4977 <  $as_echo "$as_me: failed program was:" >&5
4978 < sed 's/^/| /' conftest.$ac_ext >&5
4979 <
4980 <  # Broken: fails on valid input.
4981 < continue
4982 < fi
4983 <
4984 < rm -f conftest.err conftest.$ac_ext
4985 <
4986 <  # OK, works on sane cases.  Now check whether nonexistent headers
4987 <  # can be detected and how.
4988 <  cat >conftest.$ac_ext <<_ACEOF
4989 < /* confdefs.h.  */
4990 < _ACEOF
4991 < cat confdefs.h >>conftest.$ac_ext
4992 < cat >>conftest.$ac_ext <<_ACEOF
4993 < /* end confdefs.h.  */
4994 < #include <ac_nonexistent.h>
4995 < _ACEOF
4996 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4997 < case "(($ac_try" in
4998 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4999 <  *) ac_try_echo=$ac_try;;
5000 < esac
5001 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5002 < $as_echo "$ac_try_echo") >&5
5003 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
5004 <  ac_status=$?
5005 <  grep -v '^ *+' conftest.er1 >conftest.err
5006 <  rm -f conftest.er1
5007 <  cat conftest.err >&5
5008 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5009 <  (exit $ac_status); } >/dev/null && {
5010 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
5011 <         test ! -s conftest.err
5012 <       }; then
5013 <  # Broken: success on invalid input.
5014 < continue
5015 < else
5016 <  $as_echo "$as_me: failed program was:" >&5
5017 < sed 's/^/| /' conftest.$ac_ext >&5
5018 <
5019 <  # Passes both tests.
5020 < ac_preproc_ok=:
5021 < break
5022 < fi
5023 <
5024 < rm -f conftest.err conftest.$ac_ext
5025 <
5026 < done
5027 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5028 < rm -f conftest.err conftest.$ac_ext
5029 < if $ac_preproc_ok; then
5030 <  :
5031 < else
5032 <  { { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5033 < See \`config.log' for more details." >&5
5034 < $as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5035 < See \`config.log' for more details." >&2;}
5036 <   { (exit 1); exit 1; }; }
5037 < fi
5038 <
5039 < ac_ext=c
5040 < ac_cpp='$CPP $CPPFLAGS'
5041 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5042 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5043 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
5044 <
5045 < { $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
5046 < $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
5047 < if test "${ac_cv_path_GREP+set}" = set; then
5048 <  $as_echo_n "(cached) " >&6
5049 < else
5050 <  if test -z "$GREP"; then
5051 <  ac_path_GREP_found=false
5052 <  # Loop through the user's path and test for each of PROGNAME-LIST
5053 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5054 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
5055 < do
5056 <  IFS=$as_save_IFS
5057 <  test -z "$as_dir" && as_dir=.
5058 <  for ac_prog in grep ggrep; do
5059 <    for ac_exec_ext in '' $ac_executable_extensions; do
5060 <      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
5061 <      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
5062 < # Check for GNU ac_path_GREP and select it if it is found.
5063 <  # Check for GNU $ac_path_GREP
5064 < case `"$ac_path_GREP" --version 2>&1` in
5065 < *GNU*)
5066 <  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
5067 < *)
5068 <  ac_count=0
5069 <  $as_echo_n 0123456789 >"conftest.in"
5070 <  while :
5071 <  do
5072 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
5073 <    mv "conftest.tmp" "conftest.in"
5074 <    cp "conftest.in" "conftest.nl"
5075 <    $as_echo 'GREP' >> "conftest.nl"
5076 <    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
5077 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
5078 <    ac_count=`expr $ac_count + 1`
5079 <    if test $ac_count -gt ${ac_path_GREP_max-0}; then
5080 <      # Best one so far, save it but keep looking for a better one
5081 <      ac_cv_path_GREP="$ac_path_GREP"
5082 <      ac_path_GREP_max=$ac_count
5083 <    fi
5084 <    # 10*(2^10) chars as input seems more than enough
5085 <    test $ac_count -gt 10 && break
5086 <  done
5087 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
5088 < esac
5089 <
5090 <      $ac_path_GREP_found && break 3
5091 <    done
5092 <  done
5093 < done
5094 < IFS=$as_save_IFS
5095 <  if test -z "$ac_cv_path_GREP"; then
5096 <    { { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5097 < $as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5098 <   { (exit 1); exit 1; }; }
5099 <  fi
5100 < else
5101 <  ac_cv_path_GREP=$GREP
5102 < fi
5103 <
5104 < fi
5105 < { $as_echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
5106 < $as_echo "$ac_cv_path_GREP" >&6; }
5107 < GREP="$ac_cv_path_GREP"
5108 <
5109 <
5110 < { $as_echo "$as_me:$LINENO: checking for egrep" >&5
5111 < $as_echo_n "checking for egrep... " >&6; }
5112 < if test "${ac_cv_path_EGREP+set}" = set; then
5113 <  $as_echo_n "(cached) " >&6
5114 < else
5115 <  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
5116 <   then ac_cv_path_EGREP="$GREP -E"
5117 <   else
5118 <     if test -z "$EGREP"; then
5119 <  ac_path_EGREP_found=false
5120 <  # Loop through the user's path and test for each of PROGNAME-LIST
5121 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5122 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
5123 < do
5124 <  IFS=$as_save_IFS
5125 <  test -z "$as_dir" && as_dir=.
5126 <  for ac_prog in egrep; do
5127 <    for ac_exec_ext in '' $ac_executable_extensions; do
5128 <      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
5129 <      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
5130 < # Check for GNU ac_path_EGREP and select it if it is found.
5131 <  # Check for GNU $ac_path_EGREP
5132 < case `"$ac_path_EGREP" --version 2>&1` in
5133 < *GNU*)
5134 <  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
5135 < *)
5136 <  ac_count=0
5137 <  $as_echo_n 0123456789 >"conftest.in"
5138 <  while :
5139 <  do
5140 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
5141 <    mv "conftest.tmp" "conftest.in"
5142 <    cp "conftest.in" "conftest.nl"
5143 <    $as_echo 'EGREP' >> "conftest.nl"
5144 <    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
5145 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
5146 <    ac_count=`expr $ac_count + 1`
5147 <    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
5148 <      # Best one so far, save it but keep looking for a better one
5149 <      ac_cv_path_EGREP="$ac_path_EGREP"
5150 <      ac_path_EGREP_max=$ac_count
5151 <    fi
5152 <    # 10*(2^10) chars as input seems more than enough
5153 <    test $ac_count -gt 10 && break
5154 <  done
5155 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
5156 < esac
5157 <
5158 <      $ac_path_EGREP_found && break 3
5159 <    done
5160 <  done
5161 < done
5162 < IFS=$as_save_IFS
5163 <  if test -z "$ac_cv_path_EGREP"; then
5164 <    { { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5165 < $as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5166 <   { (exit 1); exit 1; }; }
5167 <  fi
5168 < else
5169 <  ac_cv_path_EGREP=$EGREP
5170 < fi
5171 <
5172 <   fi
5173 < fi
5174 < { $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
5175 < $as_echo "$ac_cv_path_EGREP" >&6; }
5176 < EGREP="$ac_cv_path_EGREP"
5177 <
5178 <
5179 < { $as_echo "$as_me:$LINENO: checking whether ln -s works" >&5
5180 < $as_echo_n "checking whether ln -s works... " >&6; }
5181 < LN_S=$as_ln_s
5182 < if test "$LN_S" = "ln -s"; then
5183 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
5184 < $as_echo "yes" >&6; }
5185 < else
5186 <  { $as_echo "$as_me:$LINENO: result: no, using $LN_S" >&5
5187 < $as_echo "no, using $LN_S" >&6; }
5188 < fi
5189 <
5190 < { $as_echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
5191 < $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
5192 < set x ${MAKE-make}
5193 < ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
5194 < if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
5195 <  $as_echo_n "(cached) " >&6
5196 < else
5197 <  cat >conftest.make <<\_ACEOF
5198 < SHELL = /bin/sh
5199 < all:
5200 <        @echo '@@@%%%=$(MAKE)=@@@%%%'
5201 < _ACEOF
5202 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
5203 < case `${MAKE-make} -f conftest.make 2>/dev/null` in
5204 <  *@@@%%%=?*=@@@%%%*)
5205 <    eval ac_cv_prog_make_${ac_make}_set=yes;;
5206 <  *)
5207 <    eval ac_cv_prog_make_${ac_make}_set=no;;
5208 < esac
5209 < rm -f conftest.make
5210 < fi
5211 < if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
5212 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
5213 < $as_echo "yes" >&6; }
5214 <  SET_MAKE=
5215 < else
5216 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5217 < $as_echo "no" >&6; }
5218 <  SET_MAKE="MAKE=${MAKE-make}"
5219 < fi
5220 <
5221 < if test -n "$ac_tool_prefix"; then
5222 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
5223 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
5224 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5225 < $as_echo_n "checking for $ac_word... " >&6; }
5226 < if test "${ac_cv_prog_RANLIB+set}" = set; then
5227 <  $as_echo_n "(cached) " >&6
5228 < else
5229 <  if test -n "$RANLIB"; then
5230 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
5231 < else
5232 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5233 < for as_dir in $PATH
5234 < do
5235 <  IFS=$as_save_IFS
5236 <  test -z "$as_dir" && as_dir=.
5237 <  for ac_exec_ext in '' $ac_executable_extensions; do
5238 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5239 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
5240 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5241 <    break 2
5242 <  fi
5243 < done
5244 < done
5245 < IFS=$as_save_IFS
5246 <
5247 < fi
5248 < fi
5249 < RANLIB=$ac_cv_prog_RANLIB
5250 < if test -n "$RANLIB"; then
5251 <  { $as_echo "$as_me:$LINENO: result: $RANLIB" >&5
5252 < $as_echo "$RANLIB" >&6; }
5253 < else
5254 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5255 < $as_echo "no" >&6; }
5256 < fi
5257 <
5258 <
5259 < fi
5260 < if test -z "$ac_cv_prog_RANLIB"; then
5261 <  ac_ct_RANLIB=$RANLIB
5262 <  # Extract the first word of "ranlib", so it can be a program name with args.
5263 < set dummy ranlib; ac_word=$2
5264 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5265 < $as_echo_n "checking for $ac_word... " >&6; }
5266 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
5267 <  $as_echo_n "(cached) " >&6
5268 < else
5269 <  if test -n "$ac_ct_RANLIB"; then
5270 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
5271 < else
5272 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5273 < for as_dir in $PATH
5274 < do
5275 <  IFS=$as_save_IFS
5276 <  test -z "$as_dir" && as_dir=.
5277 <  for ac_exec_ext in '' $ac_executable_extensions; do
5278 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5279 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
5280 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5281 <    break 2
5282 <  fi
5283 < done
5284 < done
5285 < IFS=$as_save_IFS
5286 <
5287 < fi
5288 < fi
5289 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
5290 < if test -n "$ac_ct_RANLIB"; then
5291 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
5292 < $as_echo "$ac_ct_RANLIB" >&6; }
5293 < else
5294 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5295 < $as_echo "no" >&6; }
5296 < fi
5297 <
5298 <  if test "x$ac_ct_RANLIB" = x; then
5299 <    RANLIB=":"
5300 <  else
5301 <    case $cross_compiling:$ac_tool_warned in
5302 < yes:)
5303 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
5304 < whose name does not start with the host triplet.  If you think this
5305 < configuration is useful to you, please write to autoconf@gnu.org." >&5
5306 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
5307 < whose name does not start with the host triplet.  If you think this
5308 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
5309 < ac_tool_warned=yes ;;
5310 < esac
5311 <    RANLIB=$ac_ct_RANLIB
5312 <  fi
5313 < else
5314 <  RANLIB="$ac_cv_prog_RANLIB"
5315 < fi
5316 <
5317 <
5318 <   # Extract the first word of "perl", so it can be a program name with args.
5319 < set dummy perl; ac_word=$2
5320 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5321 < $as_echo_n "checking for $ac_word... " >&6; }
5322 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
5323 <  $as_echo_n "(cached) " >&6
5324 < else
5325 <  case $PERLINTERP in
5326 <  [\\/]* | ?:[\\/]*)
5327 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
5328 <  ;;
5329 <  *)
5330 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5331 < for as_dir in $PATH
5332 < do
5333 <  IFS=$as_save_IFS
5334 <  test -z "$as_dir" && as_dir=.
5335 <  for ac_exec_ext in '' $ac_executable_extensions; do
5336 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5337 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
5338 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5339 <    break 2
5340 <  fi
5341 < done
5342 < done
5343 < IFS=$as_save_IFS
5344 <
5345 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
5346 <  ;;
5347 < esac
5348 < fi
5349 < PERLINTERP=$ac_cv_path_PERLINTERP
5350 < if test -n "$PERLINTERP"; then
5351 <  { $as_echo "$as_me:$LINENO: result: $PERLINTERP" >&5
5352 < $as_echo "$PERLINTERP" >&6; }
5353 < else
5354 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5355 < $as_echo "no" >&6; }
5356 < fi
5357 <
5358 <
5359 <   ac_cv_path_perlinterp="$PERLINTERP"
5360 <   _sHpB='#!'
5361 <
5362 <
5363 < # Check whether --with-perl-shebang was given.
5364 < if test "${with_perl_shebang+set}" = set; then
5365 <  withval=$with_perl_shebang; opt_perl_shebang="$withval"
5366 < else
5367 <                opt_perl_shebang="not_set"
5368 < fi
5369 <
5370 <   { $as_echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
5371 < $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
5372 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
5373 <  $as_echo_n "(cached) " >&6
5374 < else
5375 <   case "$opt_perl_shebang" in
5376 <                      not_set  ) ax_cv_opt_perl_shebang=''
5377 <                               ;;
5378 <                         *     )
5379 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
5380 <                    esac
5381 <
5382 < fi
5383 < { $as_echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
5384 < $as_echo "$ax_cv_opt_perl_shebang" >&6; }
5385 <   if test "A$ax_cv_opt_perl_shebang" != "A"
5386 <     then
5387 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
5388 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
5389 <              { $as_echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
5390 < $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
5391 <
5392 < # Automatic detection of sharpbang formula starts here
5393 <     else
5394 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
5395 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
5396 <   { $as_echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
5397 < $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
5398 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
5399 <  $as_echo_n "(cached) " >&6
5400 < else
5401 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
5402 <        if test "x$_somian_kspb_perl" == x
5403 <          then _somian_ksbp_warn_empty='durnit'
5404 <          else
5405 <          case "A$_somian_kspb_perl" in
5406 <                 A#!*perl* )
5407 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
5408 <                        ;;
5409 <                     A*    )  _somian_ksbp_warn_defau='trouble'
5410 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
5411 <          esac
5412 <        fi
5413 <
5414 < fi
5415 < { $as_echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
5416 < $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
5417 < # The above prints Checking ... result message to user.
5418 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
5419 <
5420 <    if test A${_somian_ksbp_warn_empty+set} == Aset
5421 <      then   { $as_echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
5422 < $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
5423 <    fi
5424 < # Inform user after printing result value
5425 <    if test A${_somian_ksbp_warn_defau+set} == Aset
5426 <      then { $as_echo "$as_me:$LINENO: Maybe Not good -" >&5
5427 < $as_echo "$as_me: Maybe Not good -" >&6;}
5428 <           { $as_echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
5429 < $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
5430 <      else { $as_echo "$as_me:$LINENO: OK Good result - " >&5
5431 < $as_echo "$as_me: OK Good result - " >&6;}
5432 <           { $as_echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
5433 < $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
5434 <    fi
5435 <  fi
5436 <
5437 < # Find a good install program.  We prefer a C program (faster),
5438 < # so one script is as good as another.  But avoid the broken or
5439 < # incompatible versions:
5440 < # SysV /etc/install, /usr/sbin/install
5441 < # SunOS /usr/etc/install
5442 < # IRIX /sbin/install
5443 < # AIX /bin/install
5444 < # AmigaOS /C/install, which installs bootblocks on floppy discs
5445 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
5446 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
5447 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
5448 < # OS/2's system install, which has a completely different semantic
5449 < # ./install, which can be erroneously created by make from ./install.sh.
5450 < # Reject install programs that cannot install multiple files.
5451 < { $as_echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
5452 < $as_echo_n "checking for a BSD-compatible install... " >&6; }
5453 < if test -z "$INSTALL"; then
5454 < if test "${ac_cv_path_install+set}" = set; then
5455 <  $as_echo_n "(cached) " >&6
5456 < else
5457 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5458 < for as_dir in $PATH
5459 < do
5460 <  IFS=$as_save_IFS
5461 <  test -z "$as_dir" && as_dir=.
5462 <  # Account for people who put trailing slashes in PATH elements.
5463 < case $as_dir/ in
5464 <  ./ | .// | /cC/* | \
5465 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
5466 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
5467 <  /usr/ucb/* ) ;;
5468 <  *)
5469 <    # OSF1 and SCO ODT 3.0 have their own names for install.
5470 <    # Don't use installbsd from OSF since it installs stuff as root
5471 <    # by default.
5472 <    for ac_prog in ginstall scoinst install; do
5473 <      for ac_exec_ext in '' $ac_executable_extensions; do
5474 <        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
5475 <          if test $ac_prog = install &&
5476 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
5477 <            # AIX install.  It has an incompatible calling convention.
5478 <            :
5479 <          elif test $ac_prog = install &&
5480 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
5481 <            # program-specific install script used by HP pwplus--don't use.
5482 <            :
5483 <          else
5484 <            rm -rf conftest.one conftest.two conftest.dir
5485 <            echo one > conftest.one
5486 <            echo two > conftest.two
5487 <            mkdir conftest.dir
5488 <            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
5489 <              test -s conftest.one && test -s conftest.two &&
5490 <              test -s conftest.dir/conftest.one &&
5491 <              test -s conftest.dir/conftest.two
5492 <            then
5493 <              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
5494 <              break 3
5495 <            fi
5496 <          fi
5497 <        fi
5498 <      done
5499 <    done
5500 <    ;;
5501 < esac
5502 <
5503 < done
5504 < IFS=$as_save_IFS
5505 <
5506 < rm -rf conftest.one conftest.two conftest.dir
5507 <
5508 < fi
5509 <  if test "${ac_cv_path_install+set}" = set; then
5510 <    INSTALL=$ac_cv_path_install
5511 <  else
5512 <    # As a last resort, use the slow shell script.  Don't cache a
5513 <    # value for INSTALL within a source directory, because that will
5514 <    # break other packages using the cache if that directory is
5515 <    # removed, or if the value is a relative name.
5516 <    INSTALL=$ac_install_sh
5517 <  fi
5518 < fi
5519 < { $as_echo "$as_me:$LINENO: result: $INSTALL" >&5
5520 < $as_echo "$INSTALL" >&6; }
5521 <
5522 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
5523 < # It thinks the first close brace ends the variable substitution.
5524 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
5525 <
5526 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
5527 <
5528 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
5529 <
5530 < case "x$INSTALL" in
5531 <   x/*) ;;
5532 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
5533 < esac
5534 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
5535 < # Extract the first word of "ar", so it can be a program name with args.
5536 < set dummy ar; ac_word=$2
5537 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5538 < $as_echo_n "checking for $ac_word... " >&6; }
5539 < if test "${ac_cv_prog_AR+set}" = set; then
5540 <  $as_echo_n "(cached) " >&6
5541 < else
5542 <  if test -n "$AR"; then
5543 <  ac_cv_prog_AR="$AR" # Let the user override the test.
5544 < else
5545 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5546 < for as_dir in $PATH
5547 < do
5548 <  IFS=$as_save_IFS
5549 <  test -z "$as_dir" && as_dir=.
5550 <  for ac_exec_ext in '' $ac_executable_extensions; do
5551 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5552 <    ac_cv_prog_AR="ar"
5553 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5554 <    break 2
5555 <  fi
5556 < done
5557 < done
5558 < IFS=$as_save_IFS
5559 <
5560 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
5561 < fi
5562 < fi
5563 < AR=$ac_cv_prog_AR
5564 < if test -n "$AR"; then
5565 <  { $as_echo "$as_me:$LINENO: result: $AR" >&5
5566 < $as_echo "$AR" >&6; }
5567 < else
5568 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5569 < $as_echo "no" >&6; }
5570 < fi
5571 <
5572 <
5573 < if test "$AR" = "NONE"; then
5574 <  cat >confcache <<\_ACEOF
5575 < # This file is a shell script that caches the results of configure
5576 < # tests run on this system so they can be shared between configure
5577 < # scripts and configure runs, see configure's option --config-cache.
5578 < # It is not useful on other systems.  If it contains results you don't
5579 < # want to keep, you may remove or edit it.
5580 < #
5581 < # config.status only pays attention to the cache file if you give it
5582 < # the --recheck option to rerun configure.
5583 < #
5584 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
5585 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
5586 < # following values.
5587 <
5588 < _ACEOF
5589 <
5590 < # The following way of writing the cache mishandles newlines in values,
5591 < # but we know of no workaround that is simple, portable, and efficient.
5592 < # So, we kill variables containing newlines.
5593 < # Ultrix sh set writes to stderr and can't be redirected directly,
5594 < # and sets the high bit in the cache file unless we assign to the vars.
5595 < (
5596 <  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
5597 <    eval ac_val=\$$ac_var
5598 <    case $ac_val in #(
5599 <    *${as_nl}*)
5600 <      case $ac_var in #(
5601 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
5602 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
5603 <      esac
5604 <      case $ac_var in #(
5605 <      _ | IFS | as_nl) ;; #(
5606 <      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
5607 <      *) $as_unset $ac_var ;;
5608 <      esac ;;
5609 <    esac
5610 <  done
5611 <
5612 <  (set) 2>&1 |
5613 <    case $as_nl`(ac_space=' '; set) 2>&1` in #(
5614 <    *${as_nl}ac_space=\ *)
5615 <      # `set' does not quote correctly, so add quotes (double-quote
5616 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
5617 <      sed -n \
5618 <        "s/'/'\\\\''/g;
5619 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
5620 <      ;; #(
5621 <    *)
5622 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
5623 <      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
5624 <      ;;
5625 <    esac |
5626 <    sort
5627 < ) |
5628 <  sed '
5629 <     /^ac_cv_env_/b end
5630 <     t clear
5631 <     :clear
5632 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
5633 <     t end
5634 <     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
5635 <     :end' >>confcache
5636 < if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
5637 <  if test -w "$cache_file"; then
5638 <    test "x$cache_file" != "x/dev/null" &&
5639 <      { $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
5640 < $as_echo "$as_me: updating cache $cache_file" >&6;}
5641 <    cat confcache >$cache_file
5642 <  else
5643 <    { $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
5644 < $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
5645 <  fi
5646 < fi
5647 < rm -f confcache
5648 <  exit 1
5649 < fi
5650 < # Extract the first word of "ps", so it can be a program name with args.
5651 < set dummy ps; ac_word=$2
5652 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5653 < $as_echo_n "checking for $ac_word... " >&6; }
5654 < if test "${ac_cv_path_PS+set}" = set; then
5655 <  $as_echo_n "(cached) " >&6
5656 < else
5657 <  case $PS in
5658 <  [\\/]* | ?:[\\/]*)
5659 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
5660 <  ;;
5661 <  *)
5662 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5663 < for as_dir in $PATH
5664 < do
5665 <  IFS=$as_save_IFS
5666 <  test -z "$as_dir" && as_dir=.
5667 <  for ac_exec_ext in '' $ac_executable_extensions; do
5668 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5669 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
5670 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5671 <    break 2
5672 <  fi
5673 < done
5674 < done
5675 < IFS=$as_save_IFS
5676 <
5677 <  ;;
5678 < esac
5679 < fi
5680 < PS=$ac_cv_path_PS
5681 < if test -n "$PS"; then
5682 <  { $as_echo "$as_me:$LINENO: result: $PS" >&5
5683 < $as_echo "$PS" >&6; }
5684 < else
5685 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5686 < $as_echo "no" >&6; }
5687 < fi
5688 <
5689 <
5690 < { $as_echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
5691 < $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
5692 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
5693 <  $as_echo_n "(cached) " >&6
5694 < else
5695 <
5696 <        if $PS ax -o rss > /dev/null 2>&1; then
5697 <                ac_cv_prog_ps_ax=yes
5698 <        else
5699 <                ac_cv_prog_ps_ax=no
5700 <        fi
5701 <        if $PS -ef -o rss > /dev/null 2>&1; then
5702 <                ac_cv_prog_ps_ef=yes
5703 <        else
5704 <                ac_cv_prog_ps_ef=no
5705 <        fi
5706 <        if test "$ac_cv_prog_ps_ax" = yes; then
5707 <                ac_cv_prog_ps_syntax=BSD
5708 <        else
5709 <                if test "$ac_cv_prog_ps_ef" = yes; then
5710 <                        ac_cv_prog_ps_syntax=POSIX
5711 <                else
5712 <                        { { $as_echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
5713 < $as_echo "$as_me: error: Could not determine ps syntax" >&2;}
5714 <   { (exit 1); exit 1; }; }
5715 <                fi
5716 <        fi
5717 <
5718 < fi
5719 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
5720 < $as_echo "$ac_cv_prog_ps_syntax" >&6; }
5721 <
5722 < cat >>confdefs.h <<_ACEOF
5723 < #define PSCOMMAND $PS
5724 < _ACEOF
5725 <
5726 < if test "$ac_cv_prog_ps_syntax" = BSD; then
5727 <
5728 < cat >>confdefs.h <<\_ACEOF
5729 < #define PSTYPE_IS_BSD 1
5730 < _ACEOF
5731 <
5732 < else
5733 <   if test "$ac_cv_prog_ps_syntax" = POSIX; then
5734 <
5735 < cat >>confdefs.h <<\_ACEOF
5736 < #define PSTYPE_IS_POSIX 1
5737 < _ACEOF
5738 <
5739 <   else
5740 <       { { $as_echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
5741 < $as_echo "$as_me: error: Unknown ps syntax type!" >&2;}
5742 <   { (exit 1); exit 1; }; }
5743 <   fi
5744 < fi
5745 <
5746 < ac_ext=${ac_fc_srcext-f}
5747 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5748 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5749 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5750 <
5751 <
5752 < ac_ext=${ac_fc_srcext-f}
5753 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5754 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5755 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5756 < { $as_echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
5757 < $as_echo_n "checking for Fortran flag to compile .F90 files... " >&6; }
5758 < if test "${ac_cv_fc_srcext_F90+set}" = set; then
5759 <  $as_echo_n "(cached) " >&6
5760 < else
5761 <  ac_ext=F90
5762 < ac_fcflags_srcext_save=$ac_fcflags_srcext
5763 < ac_fcflags_srcext=
5764 < ac_cv_fc_srcext_F90=unknown
5765 < for ac_flag in none -qsuffix=f=F90 -Tf; do
5766 <  test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
5767 <  cat >conftest.$ac_ext <<_ACEOF
5768 <      program main
5769 <
5770 <      end
5771 < _ACEOF
5772 < rm -f conftest.$ac_objext
5773 < if { (ac_try="$ac_compile"
5774 < case "(($ac_try" in
5775 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5776 <  *) ac_try_echo=$ac_try;;
5777 < esac
5778 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5779 < $as_echo "$ac_try_echo") >&5
5780 <  (eval "$ac_compile") 2>conftest.er1
5781 <  ac_status=$?
5782 <  grep -v '^ *+' conftest.er1 >conftest.err
5783 <  rm -f conftest.er1
5784 <  cat conftest.err >&5
5785 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5786 <  (exit $ac_status); } && {
5787 <         test -z "$ac_fc_werror_flag" ||
5788 <         test ! -s conftest.err
5789 <       } && test -s conftest.$ac_objext; then
5790 <  ac_cv_fc_srcext_F90=$ac_flag; break
5791 < else
5792 <  $as_echo "$as_me: failed program was:" >&5
5793 < sed 's/^/| /' conftest.$ac_ext >&5
5794 <
5795 <
5796 < fi
5797 <
5798 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5799 < done
5800 < rm -f conftest.$ac_objext conftest.F90
5801 < ac_fcflags_srcext=$ac_fcflags_srcext_save
5802 <
5803 < fi
5804 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
5805 < $as_echo "$ac_cv_fc_srcext_F90" >&6; }
5806 < if test "x$ac_cv_fc_srcext_F90" = xunknown; then
5807 <  { { $as_echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
5808 < $as_echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
5809 <   { (exit 1); exit 1; }; }
5810 < else
5811 <  ac_fc_srcext=F90
5812 <  if test "x$ac_cv_fc_srcext_F90" = xnone; then
5813 <    ac_fcflags_srcext=""
5814 <    FCFLAGS_F90=""
5815 <  else
5816 <    ac_fcflags_srcext=$ac_cv_fc_srcext_F90
5817 <    FCFLAGS_F90=$ac_cv_fc_srcext_F90
5818 <  fi
5819 <
5820 <
5821 < fi
5822 < ac_ext=${ac_fc_srcext-f}
5823 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5824 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5825 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5826 <
5827 <
5828 <
5829 <
5830 <
5831 < # Try to determine native compiler flags that allow us to use F90 suffix
5832 < # for preprocessed f90 source.
5833 <
5834 < if test "$ac_test_PREPFLAG" != "set"; then
5835 <  PREPFLAG=""
5836 <  case "${host_cpu}-${host_os}" in
5837 <
5838 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5839 <                    PREPFLAG="-fpp1 "
5840 <                fi;;
5841 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
5842 <                    PREPFLAG="-qsuffix=cpp=F90 "
5843 <                fi;;
5844 <  *darwin*)
5845 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
5846 <                PREPFLAG="-qsuffix=cpp=F90 "
5847 <        fi;;
5848 <  esac
5849 <
5850 <  if test -z "$PREPFLAG"; then
5851 <        { $as_echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
5852 < $as_echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
5853 <        PREPFLAG=""
5854 <  fi
5855 <
5856 <  { $as_echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
5857 < $as_echo_n "checking to make sure F90 preprocessor flag works... " >&6; }
5858 <
5859 <  ac_ext=${ac_fc_srcext-f}
5860 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5861 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5862 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5863 <
5864 <  ac_save_ext=$ac_ext
5865 <  ac_ext=F90
5866 <  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
5867 <
5868 <  if test "$PREPFLAG"; then
5869 <  FCFLAGS_SRCEXT="${PREPFLAG}"
5870 < fi
5871 <
5872 <    cat >conftest.$ac_ext <<_ACEOF
5873 <
5874 <
5875 < program conftest
5876 <  integer :: i
5877 <  i = 1
5878 < end program conftest
5879 <
5880 < _ACEOF
5881 < rm -f conftest.$ac_objext
5882 < if { (ac_try="$ac_compile"
5883 < case "(($ac_try" in
5884 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5885 <  *) ac_try_echo=$ac_try;;
5886 < esac
5887 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5888 < $as_echo "$ac_try_echo") >&5
5889 <  (eval "$ac_compile") 2>conftest.er1
5890 <  ac_status=$?
5891 <  grep -v '^ *+' conftest.er1 >conftest.err
5892 <  rm -f conftest.er1
5893 <  cat conftest.err >&5
5894 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5895 <  (exit $ac_status); } && {
5896 <         test -z "$ac_fc_werror_flag" ||
5897 <         test ! -s conftest.err
5898 <       } && test -s conftest.$ac_objext; then
5899 <  prepflagworks=1
5900 < else
5901 <  $as_echo "$as_me: failed program was:" >&5
5902 < sed 's/^/| /' conftest.$ac_ext >&5
5903 <
5904 <        prepflagworks=0
5905 < fi
5906 <
5907 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5908 <
5909 <  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
5910 <  ac_ext=$ac_save_ext
5911 <  ac_ext=${ac_fc_srcext-f}
5912 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5913 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5914 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5915 <
5916 <
5917 <  if test "$prepflagworks" = 1; then
5918 <    { $as_echo "$as_me:$LINENO: result: yes" >&5
5919 < $as_echo "yes" >&6; }
5920 <    FCFLAGS_SRCEXT="${PREPFLAG}"
5921 <
5922 <  else
5923 <    { $as_echo "$as_me:$LINENO: result: no" >&5
5924 < $as_echo "no" >&6; }
5925 <    { { $as_echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
5926 < $as_echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
5927 <   { (exit 1); exit 1; }; }
5928 <  fi
5929 < fi
5930 <
5931 <
5932 <
5933 <
5934 <
5935 < # Try to determine native compiler flags that allow us to use F90 suffix
5936 < # for preprocessed f90 source with -D type defines
5937 <
5938 < if test "$ac_test_PREPDEFFLAG" != "set"; then
5939 <  PREPDEFFLAG=""
5940 <  case "${host_cpu}-${host_os}" in
5941 <
5942 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5943 <                    PREPDEFFLAG=" "
5944 <                fi;;
5945 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
5946 <                    PREPDEFFLAG="-WF,"
5947 <                fi;;
5948 <  *darwin*)
5949 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
5950 <                PREPDEFFLAG="-WF,"
5951 <        fi;;
5952 <  esac
5953 <
5954 <  if test -z "$PREPDEFFLAG"; then
5955 <        { $as_echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
5956 < $as_echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
5957 <        PREPDEFFLAG=" "
5958 <  fi
5959 <
5960 <  { $as_echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
5961 < $as_echo_n "checking to make sure F90 preprocessor define flag works... " >&6; }
5962 <
5963 <  ac_ext=${ac_fc_srcext-f}
5964 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5965 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5966 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5967 <
5968 <  ac_save_ext=$ac_ext
5969 <  ac_ext=F90
5970 <  ac_save_FCFLAGS=$FCFLAGS
5971 <
5972 <  if test "$PREPDEFFLAG"; then
5973 <  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
5974 < fi
5975 <
5976 <    cat >conftest.$ac_ext <<_ACEOF
5977 <
5978 <
5979 < program conftest
5980 <  integer :: i
5981 < #ifdef TEST
5982 <  i = 1
5983 < #else
5984 <  choke me
5985 < #endif
5986 < end program conftest
5987 <
5988 < _ACEOF
5989 < rm -f conftest.$ac_objext
5990 < if { (ac_try="$ac_compile"
5991 < case "(($ac_try" in
5992 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5993 <  *) ac_try_echo=$ac_try;;
5994 < esac
5995 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5996 < $as_echo "$ac_try_echo") >&5
5997 <  (eval "$ac_compile") 2>conftest.er1
5998 <  ac_status=$?
5999 <  grep -v '^ *+' conftest.er1 >conftest.err
6000 <  rm -f conftest.er1
6001 <  cat conftest.err >&5
6002 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6003 <  (exit $ac_status); } && {
6004 <         test -z "$ac_fc_werror_flag" ||
6005 <         test ! -s conftest.err
6006 <       } && test -s conftest.$ac_objext; then
6007 <  prepdefflagworks=1
6008 < else
6009 <  $as_echo "$as_me: failed program was:" >&5
6010 < sed 's/^/| /' conftest.$ac_ext >&5
6011 <
6012 <        prepdefflagworks=0
6013 < fi
6014 <
6015 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6016 <
6017 <  FCFLAGS=$ac_save_FCFLAGS
6018 <  ac_ext=$ac_save_ext
6019 <  ac_ext=${ac_fc_srcext-f}
6020 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6021 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6022 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6023 <
6024 <
6025 <  if test "$prepdefflagworks" = 1; then
6026 <    { $as_echo "$as_me:$LINENO: result: yes" >&5
6027 < $as_echo "yes" >&6; }
6028 <
6029 <  else
6030 <    { $as_echo "$as_me:$LINENO: result: no" >&5
6031 < $as_echo "no" >&6; }
6032 <    { { $as_echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
6033 < $as_echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
6034 <   { (exit 1); exit 1; }; }
6035 <  fi
6036 < fi
6037 <
6038 < ac_ext=${ac_fc_srcext-f}
6039 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6040 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6041 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6042 < { $as_echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
6043 < $as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
6044 < if test "${ac_cv_prog_fc_v+set}" = set; then
6045 <  $as_echo_n "(cached) " >&6
6046 < else
6047 <  cat >conftest.$ac_ext <<_ACEOF
6048 <      program main
6049 <
6050 <      end
6051 < _ACEOF
6052 < rm -f conftest.$ac_objext
6053 < if { (ac_try="$ac_compile"
6054 < case "(($ac_try" in
6055 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6056 <  *) ac_try_echo=$ac_try;;
6057 < esac
6058 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6059 < $as_echo "$ac_try_echo") >&5
6060 <  (eval "$ac_compile") 2>conftest.er1
6061 <  ac_status=$?
6062 <  grep -v '^ *+' conftest.er1 >conftest.err
6063 <  rm -f conftest.er1
6064 <  cat conftest.err >&5
6065 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6066 <  (exit $ac_status); } && {
6067 <         test -z "$ac_fc_werror_flag" ||
6068 <         test ! -s conftest.err
6069 <       } && test -s conftest.$ac_objext; then
6070 <  ac_cv_prog_fc_v=
6071 < # Try some options frequently used verbose output
6072 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
6073 <  cat >conftest.$ac_ext <<_ACEOF
6074 <      program main
6075 <
6076 <      end
6077 < _ACEOF
6078 <
6079 < # Compile and link our simple test program by passing a flag (argument
6080 < # 1 to this macro) to the Fortran compiler in order to get
6081 < # "verbose" output that we can then parse for the Fortran linker
6082 < # flags.
6083 < ac_save_FFLAGS=$FCFLAGS
6084 < FCFLAGS="$FCFLAGS $ac_verb"
6085 < eval "set x $ac_link"
6086 < shift
6087 < $as_echo "$as_me:$LINENO: $*" >&5
6088 < # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
6089 < # LIBRARY_PATH; skip all such settings.
6090 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
6091 <  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
6092 < $as_echo "$ac_fc_v_output" >&5
6093 < FCFLAGS=$ac_save_FFLAGS
6094 <
6095 < rm -rf conftest*
6096 <
6097 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6098 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6099 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6100 < ac_fc_v_output="`echo $ac_fc_v_output |
6101 <        grep 'LPATH is:' |
6102 <        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
6103 <
6104 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6105 < #        that detects unbalanced quotes in FLIBS should be implemented
6106 < #        and (ugh) tested at some point.
6107 < case $ac_fc_v_output in
6108 <  # If we are using xlf then replace all the commas with spaces.
6109 <  *xlfentry*)
6110 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6111 <
6112 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6113 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6114 <  *mGLOB_options_string*)
6115 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6116 <
6117 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6118 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6119 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6120 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6121 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6122 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6123 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6124 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6125 <
6126 <  # If we are using Cray Fortran then delete quotes.
6127 <  *cft90*)
6128 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6129 < esac
6130 <
6131 <
6132 <  # look for -l* and *.a constructs in the output
6133 <  for ac_arg in $ac_fc_v_output; do
6134 <     case $ac_arg in
6135 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
6136 <          ac_cv_prog_fc_v=$ac_verb
6137 <          break 2 ;;
6138 <     esac
6139 <  done
6140 < done
6141 < if test -z "$ac_cv_prog_fc_v"; then
6142 <   { $as_echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
6143 < $as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
6144 < fi
6145 < else
6146 <  $as_echo "$as_me: failed program was:" >&5
6147 < sed 's/^/| /' conftest.$ac_ext >&5
6148 <
6149 <        { $as_echo "$as_me:$LINENO: WARNING: compilation failed" >&5
6150 < $as_echo "$as_me: WARNING: compilation failed" >&2;}
6151 < fi
6152 <
6153 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6154 <
6155 < fi
6156 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
6157 < $as_echo "$ac_cv_prog_fc_v" >&6; }
6158 < { $as_echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
6159 < $as_echo_n "checking for Fortran libraries of $FC... " >&6; }
6160 < if test "${ac_cv_fc_libs+set}" = set; then
6161 <  $as_echo_n "(cached) " >&6
6162 < else
6163 <  if test "x$FCLIBS" != "x"; then
6164 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
6165 < else
6166 <
6167 < cat >conftest.$ac_ext <<_ACEOF
6168 <      program main
6169 <
6170 <      end
6171 < _ACEOF
6172 <
6173 < # Compile and link our simple test program by passing a flag (argument
6174 < # 1 to this macro) to the Fortran compiler in order to get
6175 < # "verbose" output that we can then parse for the Fortran linker
6176 < # flags.
6177 < ac_save_FFLAGS=$FCFLAGS
6178 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
6179 < eval "set x $ac_link"
6180 < shift
6181 < $as_echo "$as_me:$LINENO: $*" >&5
6182 < # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
6183 < # LIBRARY_PATH; skip all such settings.
6184 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
6185 <  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
6186 < $as_echo "$ac_fc_v_output" >&5
6187 < FCFLAGS=$ac_save_FFLAGS
6188 <
6189 < rm -rf conftest*
6190 <
6191 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6192 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6193 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6194 < ac_fc_v_output="`echo $ac_fc_v_output |
6195 <        grep 'LPATH is:' |
6196 <        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
6197 <
6198 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6199 < #        that detects unbalanced quotes in FLIBS should be implemented
6200 < #        and (ugh) tested at some point.
6201 < case $ac_fc_v_output in
6202 <  # If we are using xlf then replace all the commas with spaces.
6203 <  *xlfentry*)
6204 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6205 <
6206 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6207 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6208 <  *mGLOB_options_string*)
6209 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6210 <
6211 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6212 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6213 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6214 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6215 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6216 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6217 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6218 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6219 <
6220 <  # If we are using Cray Fortran then delete quotes.
6221 <  *cft90*)
6222 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6223 < esac
6224 <
6225 <
6226 <
6227 < ac_cv_fc_libs=
6228 <
6229 < # Save positional arguments (if any)
6230 < ac_save_positional="$@"
6231 <
6232 < set X $ac_fc_v_output
6233 < while test $# != 1; do
6234 <  shift
6235 <  ac_arg=$1
6236 <  case $ac_arg in
6237 <        [\\/]*.a | ?:[\\/]*.a)
6238 <            ac_exists=false
6239 <  for ac_i in $ac_cv_fc_libs; do
6240 <    if test x"$ac_arg" = x"$ac_i"; then
6241 <      ac_exists=true
6242 <      break
6243 <    fi
6244 <  done
6245 <
6246 <  if test x"$ac_exists" = xtrue; then
6247 <  :
6248 < else
6249 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6250 < fi
6251 <
6252 <          ;;
6253 <        -bI:*)
6254 <            ac_exists=false
6255 <  for ac_i in $ac_cv_fc_libs; do
6256 <    if test x"$ac_arg" = x"$ac_i"; then
6257 <      ac_exists=true
6258 <      break
6259 <    fi
6260 <  done
6261 <
6262 <  if test x"$ac_exists" = xtrue; then
6263 <  :
6264 < else
6265 <  if test "$ac_compiler_gnu" = yes; then
6266 <  for ac_link_opt in $ac_arg; do
6267 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6268 <  done
6269 < else
6270 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6271 < fi
6272 < fi
6273 <
6274 <          ;;
6275 <          # Ignore these flags.
6276 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
6277 <          ;;
6278 <        -lkernel32)
6279 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6280 <          ;;
6281 <        -[LRuYz])
6282 <          # These flags, when seen by themselves, take an argument.
6283 <          # We remove the space between option and argument and re-iterate
6284 <          # unless we find an empty arg or a new option (starting with -)
6285 <          case $2 in
6286 <             "" | -*);;
6287 <             *)
6288 <                ac_arg="$ac_arg$2"
6289 <                shift; shift
6290 <                set X $ac_arg "$@"
6291 <                ;;
6292 <          esac
6293 <          ;;
6294 <        -YP,*)
6295 <          for ac_j in `$as_echo "$ac_arg" | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
6296 <              ac_exists=false
6297 <  for ac_i in $ac_cv_fc_libs; do
6298 <    if test x"$ac_j" = x"$ac_i"; then
6299 <      ac_exists=true
6300 <      break
6301 <    fi
6302 <  done
6303 <
6304 <  if test x"$ac_exists" = xtrue; then
6305 <  :
6306 < else
6307 <  ac_arg="$ac_arg $ac_j"
6308 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
6309 < fi
6310 <
6311 <          done
6312 <          ;;
6313 <        -[lLR]*)
6314 <            ac_exists=false
6315 <  for ac_i in $ac_cv_fc_libs; do
6316 <    if test x"$ac_arg" = x"$ac_i"; then
6317 <      ac_exists=true
6318 <      break
6319 <    fi
6320 <  done
6321 <
6322 <  if test x"$ac_exists" = xtrue; then
6323 <  :
6324 < else
6325 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6326 < fi
6327 <
6328 <          ;;
6329 <        -zallextract*| -zdefaultextract)
6330 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6331 <          ;;
6332 <          # Ignore everything else.
6333 <  esac
6334 < done
6335 < # restore positional arguments
6336 < set X $ac_save_positional; shift
6337 <
6338 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
6339 < # then we insist that the "run path" must be an absolute path (i.e. it
6340 < # must begin with a "/").
6341 < case `(uname -sr) 2>/dev/null` in
6342 <   "SunOS 5"*)
6343 <      ac_ld_run_path=`$as_echo "$ac_fc_v_output" |
6344 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
6345 <      test "x$ac_ld_run_path" != x &&
6346 <        if test "$ac_compiler_gnu" = yes; then
6347 <  for ac_link_opt in $ac_ld_run_path; do
6348 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6349 <  done
6350 < else
6351 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
6352 < fi
6353 <      ;;
6354 < esac
6355 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
6356 <
6357 < fi
6358 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
6359 < $as_echo "$ac_cv_fc_libs" >&6; }
6360 < FCLIBS="$ac_cv_fc_libs"
6361 <
6362 <
6363 < ac_ext=${ac_fc_srcext-f}
6364 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6365 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6366 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6367 <
6368 <
6369 < ac_ext=${ac_fc_srcext-f}
6370 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6371 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6372 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6373 <
6374 < { $as_echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
6375 < $as_echo_n "checking for dummy main to link with Fortran libraries... " >&6; }
6376 < if test "${ac_cv_fc_dummy_main+set}" = set; then
6377 <  $as_echo_n "(cached) " >&6
6378 < else
6379 <  ac_fc_dm_save_LIBS=$LIBS
6380 < LIBS="$LIBS $FCLIBS"
6381 < ac_fortran_dm_var=FC_DUMMY_MAIN
6382 < ac_ext=c
6383 < ac_cpp='$CPP $CPPFLAGS'
6384 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6385 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6386 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6387 <
6388 < # First, try linking without a dummy main:
6389 < cat >conftest.$ac_ext <<_ACEOF
6390 < /* confdefs.h.  */
6391 < _ACEOF
6392 < cat confdefs.h >>conftest.$ac_ext
6393 < cat >>conftest.$ac_ext <<_ACEOF
6394 < /* end confdefs.h.  */
6395 <
6396 < #ifdef FC_DUMMY_MAIN
6397 < #ifndef FC_DUMMY_MAIN_EQ_F77
6398 < #  ifdef __cplusplus
6399 <     extern "C"
6400 < #  endif
6401 <   int FC_DUMMY_MAIN() { return 1; }
6402 < #endif
6403 < #endif
6404 < int
6405 < main ()
6406 < {
6407 <
6408 <  ;
6409 <  return 0;
6410 < }
6411 < _ACEOF
6412 < rm -f conftest.$ac_objext conftest$ac_exeext
6413 < if { (ac_try="$ac_link"
6414 < case "(($ac_try" in
6415 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6416 <  *) ac_try_echo=$ac_try;;
6417 < esac
6418 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6419 < $as_echo "$ac_try_echo") >&5
6420 <  (eval "$ac_link") 2>conftest.er1
6421 <  ac_status=$?
6422 <  grep -v '^ *+' conftest.er1 >conftest.err
6423 <  rm -f conftest.er1
6424 <  cat conftest.err >&5
6425 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6426 <  (exit $ac_status); } && {
6427 <         test -z "$ac_c_werror_flag" ||
6428 <         test ! -s conftest.err
6429 <       } && test -s conftest$ac_exeext && {
6430 <         test "$cross_compiling" = yes ||
6431 <         $as_test_x conftest$ac_exeext
6432 <       }; then
6433 <  ac_cv_fortran_dummy_main=none
6434 < else
6435 <  $as_echo "$as_me: failed program was:" >&5
6436 < sed 's/^/| /' conftest.$ac_ext >&5
6437 <
6438 <        ac_cv_fortran_dummy_main=unknown
6439 < fi
6440 <
6441 < rm -rf conftest.dSYM
6442 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6443 <      conftest$ac_exeext conftest.$ac_ext
6444 <
6445 < if test $ac_cv_fortran_dummy_main = unknown; then
6446 <   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
6447 <     cat >conftest.$ac_ext <<_ACEOF
6448 < /* confdefs.h.  */
6449 < _ACEOF
6450 < cat confdefs.h >>conftest.$ac_ext
6451 < cat >>conftest.$ac_ext <<_ACEOF
6452 < /* end confdefs.h.  */
6453 < #define $ac_fortran_dm_var $ac_func
6454 < #ifdef FC_DUMMY_MAIN
6455 < #ifndef FC_DUMMY_MAIN_EQ_F77
6456 < #  ifdef __cplusplus
6457 <     extern "C"
6458 < #  endif
6459 <   int FC_DUMMY_MAIN() { return 1; }
6460 < #endif
6461 < #endif
6462 < int
6463 < main ()
6464 < {
6465 <
6466 <  ;
6467 <  return 0;
6468 < }
6469 < _ACEOF
6470 < rm -f conftest.$ac_objext conftest$ac_exeext
6471 < if { (ac_try="$ac_link"
6472 < case "(($ac_try" in
6473 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6474 <  *) ac_try_echo=$ac_try;;
6475 < esac
6476 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6477 < $as_echo "$ac_try_echo") >&5
6478 <  (eval "$ac_link") 2>conftest.er1
6479 <  ac_status=$?
6480 <  grep -v '^ *+' conftest.er1 >conftest.err
6481 <  rm -f conftest.er1
6482 <  cat conftest.err >&5
6483 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6484 <  (exit $ac_status); } && {
6485 <         test -z "$ac_c_werror_flag" ||
6486 <         test ! -s conftest.err
6487 <       } && test -s conftest$ac_exeext && {
6488 <         test "$cross_compiling" = yes ||
6489 <         $as_test_x conftest$ac_exeext
6490 <       }; then
6491 <  ac_cv_fortran_dummy_main=$ac_func; break
6492 < else
6493 <  $as_echo "$as_me: failed program was:" >&5
6494 < sed 's/^/| /' conftest.$ac_ext >&5
6495 <
6496 <
6497 < fi
6498 <
6499 < rm -rf conftest.dSYM
6500 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6501 <      conftest$ac_exeext conftest.$ac_ext
6502 <   done
6503 < fi
6504 < ac_ext=${ac_fc_srcext-f}
6505 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6506 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6507 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6508 < ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
6509 < rm -rf conftest*
6510 < LIBS=$ac_fc_dm_save_LIBS
6511 <
6512 < fi
6513 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
6514 < $as_echo "$ac_cv_fc_dummy_main" >&6; }
6515 < FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
6516 < if test "$FC_DUMMY_MAIN" != unknown; then
6517 <  if test $FC_DUMMY_MAIN != none; then
6518 <
6519 < cat >>confdefs.h <<_ACEOF
6520 < #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
6521 < _ACEOF
6522 <
6523 <  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
6524 <
6525 < cat >>confdefs.h <<\_ACEOF
6526 < #define FC_DUMMY_MAIN_EQ_F77 1
6527 < _ACEOF
6528 <
6529 <  fi
6530 < fi
6531 < else
6532 <  { { $as_echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
6533 < See \`config.log' for more details." >&5
6534 < $as_echo "$as_me: error: linking to Fortran libraries from C fails
6535 < See \`config.log' for more details." >&2;}
6536 <   { (exit 1); exit 1; }; }
6537 < fi
6538 <
6539 <
6540 < ac_ext=${ac_fc_srcext-f}
6541 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6542 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6543 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6544 <
6545 < ac_ext=${ac_fc_srcext-f}
6546 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6547 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6548 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6549 < { $as_echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
6550 < $as_echo_n "checking for Fortran name-mangling scheme... " >&6; }
6551 < if test "${ac_cv_fc_mangling+set}" = set; then
6552 <  $as_echo_n "(cached) " >&6
6553 < else
6554 <  cat >conftest.$ac_ext <<_ACEOF
6555 <      subroutine foobar()
6556 <      return
6557 <      end
6558 <      subroutine foo_bar()
6559 <      return
6560 <      end
6561 < _ACEOF
6562 < rm -f conftest.$ac_objext
6563 < if { (ac_try="$ac_compile"
6564 < case "(($ac_try" in
6565 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6566 <  *) ac_try_echo=$ac_try;;
6567 < esac
6568 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6569 < $as_echo "$ac_try_echo") >&5
6570 <  (eval "$ac_compile") 2>conftest.er1
6571 <  ac_status=$?
6572 <  grep -v '^ *+' conftest.er1 >conftest.err
6573 <  rm -f conftest.er1
6574 <  cat conftest.err >&5
6575 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6576 <  (exit $ac_status); } && {
6577 <         test -z "$ac_fc_werror_flag" ||
6578 <         test ! -s conftest.err
6579 <       } && test -s conftest.$ac_objext; then
6580 <  mv conftest.$ac_objext cfortran_test.$ac_objext
6581 <
6582 <  ac_save_LIBS=$LIBS
6583 <  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
6584 <
6585 <  ac_ext=c
6586 < ac_cpp='$CPP $CPPFLAGS'
6587 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6588 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6589 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6590 <  ac_success=no
6591 <  for ac_foobar in foobar FOOBAR; do
6592 <    for ac_underscore in "" "_"; do
6593 <      ac_func="$ac_foobar$ac_underscore"
6594 <      cat >conftest.$ac_ext <<_ACEOF
6595 < /* confdefs.h.  */
6596 < _ACEOF
6597 < cat confdefs.h >>conftest.$ac_ext
6598 < cat >>conftest.$ac_ext <<_ACEOF
6599 < /* end confdefs.h.  */
6600 <
6601 < /* Override any GCC internal prototype to avoid an error.
6602 <   Use char because int might match the return type of a GCC
6603 <   builtin and then its argument prototype would still apply.  */
6604 < #ifdef __cplusplus
6605 < extern "C"
6606 < #endif
6607 < char $ac_func ();
6608 < #ifdef FC_DUMMY_MAIN
6609 < #ifndef FC_DUMMY_MAIN_EQ_F77
6610 < #  ifdef __cplusplus
6611 <     extern "C"
6612 < #  endif
6613 <   int FC_DUMMY_MAIN() { return 1; }
6614 < #endif
6615 < #endif
6616 < int
6617 < main ()
6618 < {
6619 < return $ac_func ();
6620 <  ;
6621 <  return 0;
6622 < }
6623 < _ACEOF
6624 < rm -f conftest.$ac_objext conftest$ac_exeext
6625 < if { (ac_try="$ac_link"
6626 < case "(($ac_try" in
6627 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6628 <  *) ac_try_echo=$ac_try;;
6629 < esac
6630 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6631 < $as_echo "$ac_try_echo") >&5
6632 <  (eval "$ac_link") 2>conftest.er1
6633 <  ac_status=$?
6634 <  grep -v '^ *+' conftest.er1 >conftest.err
6635 <  rm -f conftest.er1
6636 <  cat conftest.err >&5
6637 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6638 <  (exit $ac_status); } && {
6639 <         test -z "$ac_c_werror_flag" ||
6640 <         test ! -s conftest.err
6641 <       } && test -s conftest$ac_exeext && {
6642 <         test "$cross_compiling" = yes ||
6643 <         $as_test_x conftest$ac_exeext
6644 <       }; then
6645 <  ac_success=yes; break 2
6646 < else
6647 <  $as_echo "$as_me: failed program was:" >&5
6648 < sed 's/^/| /' conftest.$ac_ext >&5
6649 <
6650 <
6651 < fi
6652 <
6653 < rm -rf conftest.dSYM
6654 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6655 <      conftest$ac_exeext conftest.$ac_ext
6656 <    done
6657 <  done
6658 <  ac_ext=${ac_fc_srcext-f}
6659 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6660 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6661 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6662 <
6663 <  if test "$ac_success" = "yes"; then
6664 <     case $ac_foobar in
6665 <        foobar)
6666 <           ac_case=lower
6667 <           ac_foo_bar=foo_bar
6668 <           ;;
6669 <        FOOBAR)
6670 <           ac_case=upper
6671 <           ac_foo_bar=FOO_BAR
6672 <           ;;
6673 <     esac
6674 <
6675 <     ac_ext=c
6676 < ac_cpp='$CPP $CPPFLAGS'
6677 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6678 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6679 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6680 <     ac_success_extra=no
6681 <     for ac_extra in "" "_"; do
6682 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
6683 <        cat >conftest.$ac_ext <<_ACEOF
6684 < /* confdefs.h.  */
6685 < _ACEOF
6686 < cat confdefs.h >>conftest.$ac_ext
6687 < cat >>conftest.$ac_ext <<_ACEOF
6688 < /* end confdefs.h.  */
6689 <
6690 < /* Override any GCC internal prototype to avoid an error.
6691 <   Use char because int might match the return type of a GCC
6692 <   builtin and then its argument prototype would still apply.  */
6693 < #ifdef __cplusplus
6694 < extern "C"
6695 < #endif
6696 < char $ac_func ();
6697 < #ifdef FC_DUMMY_MAIN
6698 < #ifndef FC_DUMMY_MAIN_EQ_F77
6699 < #  ifdef __cplusplus
6700 <     extern "C"
6701 < #  endif
6702 <   int FC_DUMMY_MAIN() { return 1; }
6703 < #endif
6704 < #endif
6705 < int
6706 < main ()
6707 < {
6708 < return $ac_func ();
6709 <  ;
6710 <  return 0;
6711 < }
6712 < _ACEOF
6713 < rm -f conftest.$ac_objext conftest$ac_exeext
6714 < if { (ac_try="$ac_link"
6715 < case "(($ac_try" in
6716 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6717 <  *) ac_try_echo=$ac_try;;
6718 < esac
6719 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6720 < $as_echo "$ac_try_echo") >&5
6721 <  (eval "$ac_link") 2>conftest.er1
6722 <  ac_status=$?
6723 <  grep -v '^ *+' conftest.er1 >conftest.err
6724 <  rm -f conftest.er1
6725 <  cat conftest.err >&5
6726 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6727 <  (exit $ac_status); } && {
6728 <         test -z "$ac_c_werror_flag" ||
6729 <         test ! -s conftest.err
6730 <       } && test -s conftest$ac_exeext && {
6731 <         test "$cross_compiling" = yes ||
6732 <         $as_test_x conftest$ac_exeext
6733 <       }; then
6734 <  ac_success_extra=yes; break
6735 < else
6736 <  $as_echo "$as_me: failed program was:" >&5
6737 < sed 's/^/| /' conftest.$ac_ext >&5
6738 <
6739 <
6740 < fi
6741 <
6742 < rm -rf conftest.dSYM
6743 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6744 <      conftest$ac_exeext conftest.$ac_ext
6745 <     done
6746 <     ac_ext=${ac_fc_srcext-f}
6747 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6748 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6749 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6750 <
6751 <     if test "$ac_success_extra" = "yes"; then
6752 <        ac_cv_fc_mangling="$ac_case case"
6753 <        if test -z "$ac_underscore"; then
6754 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
6755 <        else
6756 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
6757 <        fi
6758 <        if test -z "$ac_extra"; then
6759 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
6760 <        else
6761 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
6762 <        fi
4703 >  ac_check_lib_save_LIBS=$LIBS
4704 > LIBS="-lmpi  $LIBS"
4705 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4706 > /* end confdefs.h.  */
4707 >
4708 > /* Override any GCC internal prototype to avoid an error.
4709 >   Use char because int might match the return type of a GCC
4710 >   builtin and then its argument prototype would still apply.  */
4711 > #ifdef __cplusplus
4712 > extern "C"
4713 > #endif
4714 > char MPI_Init ();
4715 > int
4716 > main ()
4717 > {
4718 > return MPI_Init ();
4719 >  ;
4720 >  return 0;
4721 > }
4722 > _ACEOF
4723 > if ac_fn_c_try_link "$LINENO"; then :
4724 >  ac_cv_lib_mpi_MPI_Init=yes
4725 > else
4726 >  ac_cv_lib_mpi_MPI_Init=no
4727 > fi
4728 > rm -f core conftest.err conftest.$ac_objext \
4729 >    conftest$ac_exeext conftest.$ac_ext
4730 > LIBS=$ac_check_lib_save_LIBS
4731 > fi
4732 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4733 > $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4734 > if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
4735 >  MPILIBS="-lmpi"
4736 > fi
4737 >
4738 > fi
4739 > if test x = x"$MPILIBS"; then
4740 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4741 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4742 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
4743 >  $as_echo_n "(cached) " >&6
4744 > else
4745 >  ac_check_lib_save_LIBS=$LIBS
4746 > LIBS="-lmpich  $LIBS"
4747 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4748 > /* end confdefs.h.  */
4749 >
4750 > /* Override any GCC internal prototype to avoid an error.
4751 >   Use char because int might match the return type of a GCC
4752 >   builtin and then its argument prototype would still apply.  */
4753 > #ifdef __cplusplus
4754 > extern "C"
4755 > #endif
4756 > char MPI_Init ();
4757 > int
4758 > main ()
4759 > {
4760 > return MPI_Init ();
4761 >  ;
4762 >  return 0;
4763 > }
4764 > _ACEOF
4765 > if ac_fn_c_try_link "$LINENO"; then :
4766 >  ac_cv_lib_mpich_MPI_Init=yes
4767 > else
4768 >  ac_cv_lib_mpich_MPI_Init=no
4769 > fi
4770 > rm -f core conftest.err conftest.$ac_objext \
4771 >    conftest$ac_exeext conftest.$ac_ext
4772 > LIBS=$ac_check_lib_save_LIBS
4773 > fi
4774 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4775 > $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4776 > if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
4777 >  MPILIBS="-lmpich"
4778 > fi
4779 >
4780 > fi
4781 >
4782 > if test x != x"$MPILIBS"; then
4783 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4784 > $as_echo_n "checking for mpi.h... " >&6; }
4785 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4786 > /* end confdefs.h.  */
4787 > #include <mpi.h>
4788 > int
4789 > main ()
4790 > {
4791 >
4792 >  ;
4793 >  return 0;
4794 > }
4795 > _ACEOF
4796 > if ac_fn_c_try_compile "$LINENO"; then :
4797 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4798 > $as_echo "yes" >&6; }
4799 > else
4800 >  MPILIBS=""
4801 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4802 > $as_echo "no" >&6; }
4803 > fi
4804 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4805 > fi
4806 >
4807 > CC="$ax_mpi_save_CC"
4808 >
4809 >
4810 >
4811 > # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4812 > if test x = x"$MPILIBS"; then
4813 >        USE_MPI="no"
4814 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. oopse_MPI will not be built." >&5
4815 > $as_echo "$as_me: WARNING: No suitable C MPI implementation found. oopse_MPI will not be built." >&2;}
4816 >        :
4817 > else
4818 >        USE_MPI="yes"
4819 >        :
4820 > fi
4821 >
4822 >
4823 > fi
4824 > ac_ext=${ac_fc_srcext-f}
4825 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4826 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4827 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4828 > if test -n "$ac_tool_prefix"; then
4829 >  for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4830 >  do
4831 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4832 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4833 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4834 > $as_echo_n "checking for $ac_word... " >&6; }
4835 > if test "${ac_cv_prog_FC+set}" = set; then :
4836 >  $as_echo_n "(cached) " >&6
4837 > else
4838 >  if test -n "$FC"; then
4839 >  ac_cv_prog_FC="$FC" # Let the user override the test.
4840 > else
4841 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4842 > for as_dir in $PATH
4843 > do
4844 >  IFS=$as_save_IFS
4845 >  test -z "$as_dir" && as_dir=.
4846 >    for ac_exec_ext in '' $ac_executable_extensions; do
4847 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4848 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4849 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4850 >    break 2
4851 >  fi
4852 > done
4853 >  done
4854 > IFS=$as_save_IFS
4855 >
4856 > fi
4857 > fi
4858 > FC=$ac_cv_prog_FC
4859 > if test -n "$FC"; then
4860 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
4861 > $as_echo "$FC" >&6; }
4862 > else
4863 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4864 > $as_echo "no" >&6; }
4865 > fi
4866 >
4867 >
4868 >    test -n "$FC" && break
4869 >  done
4870 > fi
4871 > if test -z "$FC"; then
4872 >  ac_ct_FC=$FC
4873 >  for ac_prog in gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn xlf90 f90 pgf90 pghpf epcf90 g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77
4874 > do
4875 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
4876 > set dummy $ac_prog; ac_word=$2
4877 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4878 > $as_echo_n "checking for $ac_word... " >&6; }
4879 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
4880 >  $as_echo_n "(cached) " >&6
4881 > else
4882 >  if test -n "$ac_ct_FC"; then
4883 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4884 > else
4885 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4886 > for as_dir in $PATH
4887 > do
4888 >  IFS=$as_save_IFS
4889 >  test -z "$as_dir" && as_dir=.
4890 >    for ac_exec_ext in '' $ac_executable_extensions; do
4891 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4892 >    ac_cv_prog_ac_ct_FC="$ac_prog"
4893 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4894 >    break 2
4895 >  fi
4896 > done
4897 >  done
4898 > IFS=$as_save_IFS
4899 >
4900 > fi
4901 > fi
4902 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
4903 > if test -n "$ac_ct_FC"; then
4904 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
4905 > $as_echo "$ac_ct_FC" >&6; }
4906 > else
4907 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4908 > $as_echo "no" >&6; }
4909 > fi
4910 >
4911 >
4912 >  test -n "$ac_ct_FC" && break
4913 > done
4914 >
4915 >  if test "x$ac_ct_FC" = x; then
4916 >    FC=""
4917 >  else
4918 >    case $cross_compiling:$ac_tool_warned in
4919 > yes:)
4920 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4921 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4922 > ac_tool_warned=yes ;;
4923 > esac
4924 >    FC=$ac_ct_FC
4925 >  fi
4926 > fi
4927 >
4928 >
4929 > # Provide some information about the compiler.
4930 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
4931 > set X $ac_compile
4932 > ac_compiler=$2
4933 > for ac_option in --version -v -V -qversion; do
4934 >  { { ac_try="$ac_compiler $ac_option >&5"
4935 > case "(($ac_try" in
4936 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4937 >  *) ac_try_echo=$ac_try;;
4938 > esac
4939 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
4940 > $as_echo "$ac_try_echo"; } >&5
4941 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
4942 >  ac_status=$?
4943 >  if test -s conftest.err; then
4944 >    sed '10a\
4945 > ... rest of stderr output deleted ...
4946 >         10q' conftest.err >conftest.er1
4947 >    cat conftest.er1 >&5
4948 >    rm -f conftest.er1 conftest.err
4949 >  fi
4950 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
4951 >  test $ac_status = 0; }
4952 > done
4953 > rm -f a.out
4954 >
4955 > # If we don't use `.F' as extension, the preprocessor is not run on the
4956 > # input file.  (Note that this only needs to work for GNU compilers.)
4957 > ac_save_ext=$ac_ext
4958 > ac_ext=F
4959 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
4960 > $as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4961 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
4962 >  $as_echo_n "(cached) " >&6
4963 > else
4964 >  cat > conftest.$ac_ext <<_ACEOF
4965 >      program main
4966 > #ifndef __GNUC__
4967 >       choke me
4968 > #endif
4969 >
4970 >      end
4971 > _ACEOF
4972 > if ac_fn_fc_try_compile "$LINENO"; then :
4973 >  ac_compiler_gnu=yes
4974 > else
4975 >  ac_compiler_gnu=no
4976 > fi
4977 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4978 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4979 >
4980 > fi
4981 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
4982 > $as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4983 > ac_ext=$ac_save_ext
4984 > ac_test_FCFLAGS=${FCFLAGS+set}
4985 > ac_save_FCFLAGS=$FCFLAGS
4986 > FCFLAGS=
4987 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
4988 > $as_echo_n "checking whether $FC accepts -g... " >&6; }
4989 > if test "${ac_cv_prog_fc_g+set}" = set; then :
4990 >  $as_echo_n "(cached) " >&6
4991 > else
4992 >  FCFLAGS=-g
4993 > cat > conftest.$ac_ext <<_ACEOF
4994 >      program main
4995 >
4996 >      end
4997 > _ACEOF
4998 > if ac_fn_fc_try_compile "$LINENO"; then :
4999 >  ac_cv_prog_fc_g=yes
5000 > else
5001 >  ac_cv_prog_fc_g=no
5002 > fi
5003 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5004 >
5005 > fi
5006 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
5007 > $as_echo "$ac_cv_prog_fc_g" >&6; }
5008 > if test "$ac_test_FCFLAGS" = set; then
5009 >  FCFLAGS=$ac_save_FCFLAGS
5010 > elif test $ac_cv_prog_fc_g = yes; then
5011 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5012 >    FCFLAGS="-g -O2"
5013 >  else
5014 >    FCFLAGS="-g"
5015 >  fi
5016 > else
5017 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5018 >    FCFLAGS="-O2"
5019 >  else
5020 >    FCFLAGS=
5021 >  fi
5022 > fi
5023 >
5024 > ac_ext=${ac_fc_srcext-f}
5025 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5026 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5027 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5028 >
5029 >
5030 > if test $USE_MPI != no; then :
5031 >
5032 > ac_ext=${ac_fc_srcext-f}
5033 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5034 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5035 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5036 >
5037 >
5038 >
5039 >
5040 >
5041 >
5042 >        for ac_prog in openmpif90 mpif90 mpxlf95_r mpxlf90_r mpxlf95 mpxlf90 mpf90 cmpif90c
5043 > do
5044 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
5045 > set dummy $ac_prog; ac_word=$2
5046 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5047 > $as_echo_n "checking for $ac_word... " >&6; }
5048 > if test "${ac_cv_prog_MPIFC+set}" = set; then :
5049 >  $as_echo_n "(cached) " >&6
5050 > else
5051 >  if test -n "$MPIFC"; then
5052 >  ac_cv_prog_MPIFC="$MPIFC" # Let the user override the test.
5053 > else
5054 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5055 > for as_dir in $PATH
5056 > do
5057 >  IFS=$as_save_IFS
5058 >  test -z "$as_dir" && as_dir=.
5059 >    for ac_exec_ext in '' $ac_executable_extensions; do
5060 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5061 >    ac_cv_prog_MPIFC="$ac_prog"
5062 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5063 >    break 2
5064 >  fi
5065 > done
5066 >  done
5067 > IFS=$as_save_IFS
5068 >
5069 > fi
5070 > fi
5071 > MPIFC=$ac_cv_prog_MPIFC
5072 > if test -n "$MPIFC"; then
5073 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPIFC" >&5
5074 > $as_echo "$MPIFC" >&6; }
5075 > else
5076 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5077 > $as_echo "no" >&6; }
5078 > fi
5079 >
5080 >
5081 >  test -n "$MPIFC" && break
5082 > done
5083 > test -n "$MPIFC" || MPIFC="$FC"
5084 >
5085 >        ax_mpi_save_FC="$FC"
5086 >        FC="$MPIFC"
5087 >
5088 >
5089 >
5090 > if test x = x"$MPILIBS"; then
5091 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init" >&5
5092 > $as_echo_n "checking for MPI_Init... " >&6; }
5093 >                        cat > conftest.$ac_ext <<_ACEOF
5094 >      program main
5095 >      call MPI_Init
5096 >      end
5097 > _ACEOF
5098 > if ac_fn_fc_try_link "$LINENO"; then :
5099 >  MPILIBS=" "
5100 >                                { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5101 > $as_echo "yes" >&6; }
5102 > else
5103 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5104 > $as_echo "no" >&6; }
5105 > fi
5106 > rm -f core conftest.err conftest.$ac_objext \
5107 >    conftest$ac_exeext conftest.$ac_ext
5108 > fi
5109 >
5110 >        if test x = x"$MPILIBS"; then
5111 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lfmpi" >&5
5112 > $as_echo_n "checking for MPI_Init in -lfmpi... " >&6; }
5113 > if test "${ac_cv_lib_fmpi_MPI_Init+set}" = set; then :
5114 >  $as_echo_n "(cached) " >&6
5115 > else
5116 >  ac_check_lib_save_LIBS=$LIBS
5117 > LIBS="-lfmpi  $LIBS"
5118 > cat > conftest.$ac_ext <<_ACEOF
5119 >      program main
5120 >      call MPI_Init
5121 >      end
5122 > _ACEOF
5123 > if ac_fn_fc_try_link "$LINENO"; then :
5124 >  ac_cv_lib_fmpi_MPI_Init=yes
5125 > else
5126 >  ac_cv_lib_fmpi_MPI_Init=no
5127 > fi
5128 > rm -f core conftest.err conftest.$ac_objext \
5129 >    conftest$ac_exeext conftest.$ac_ext
5130 > LIBS=$ac_check_lib_save_LIBS
5131 > fi
5132 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fmpi_MPI_Init" >&5
5133 > $as_echo "$ac_cv_lib_fmpi_MPI_Init" >&6; }
5134 > if test "x$ac_cv_lib_fmpi_MPI_Init" = x""yes; then :
5135 >  MPILIBS="-lfmpi"
5136 > fi
5137 >
5138 >        fi
5139 >        if test x = x"$MPILIBS"; then
5140 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpichf90" >&5
5141 > $as_echo_n "checking for MPI_Init in -lmpichf90... " >&6; }
5142 > if test "${ac_cv_lib_mpichf90_MPI_Init+set}" = set; then :
5143 >  $as_echo_n "(cached) " >&6
5144 > else
5145 >  ac_check_lib_save_LIBS=$LIBS
5146 > LIBS="-lmpichf90  $LIBS"
5147 > cat > conftest.$ac_ext <<_ACEOF
5148 >      program main
5149 >      call MPI_Init
5150 >      end
5151 > _ACEOF
5152 > if ac_fn_fc_try_link "$LINENO"; then :
5153 >  ac_cv_lib_mpichf90_MPI_Init=yes
5154 > else
5155 >  ac_cv_lib_mpichf90_MPI_Init=no
5156 > fi
5157 > rm -f core conftest.err conftest.$ac_objext \
5158 >    conftest$ac_exeext conftest.$ac_ext
5159 > LIBS=$ac_check_lib_save_LIBS
5160 > fi
5161 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpichf90_MPI_Init" >&5
5162 > $as_echo "$ac_cv_lib_mpichf90_MPI_Init" >&6; }
5163 > if test "x$ac_cv_lib_mpichf90_MPI_Init" = x""yes; then :
5164 >  MPILIBS="-lmpichf90"
5165 > fi
5166 >
5167 >        fi
5168 >
5169 > if test x = x"$MPILIBS"; then
5170 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
5171 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
5172 > if test "${ac_cv_lib_mpi_MPI_Init+set}" = set; then :
5173 >  $as_echo_n "(cached) " >&6
5174 > else
5175 >  ac_check_lib_save_LIBS=$LIBS
5176 > LIBS="-lmpi  $LIBS"
5177 > cat > conftest.$ac_ext <<_ACEOF
5178 >      program main
5179 >      call MPI_Init
5180 >      end
5181 > _ACEOF
5182 > if ac_fn_fc_try_link "$LINENO"; then :
5183 >  ac_cv_lib_mpi_MPI_Init=yes
5184 > else
5185 >  ac_cv_lib_mpi_MPI_Init=no
5186 > fi
5187 > rm -f core conftest.err conftest.$ac_objext \
5188 >    conftest$ac_exeext conftest.$ac_ext
5189 > LIBS=$ac_check_lib_save_LIBS
5190 > fi
5191 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
5192 > $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
5193 > if test "x$ac_cv_lib_mpi_MPI_Init" = x""yes; then :
5194 >  MPILIBS="-lmpi"
5195 > fi
5196 >
5197 > fi
5198 > if test x = x"$MPILIBS"; then
5199 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
5200 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
5201 > if test "${ac_cv_lib_mpich_MPI_Init+set}" = set; then :
5202 >  $as_echo_n "(cached) " >&6
5203 > else
5204 >  ac_check_lib_save_LIBS=$LIBS
5205 > LIBS="-lmpich  $LIBS"
5206 > cat > conftest.$ac_ext <<_ACEOF
5207 >      program main
5208 >      call MPI_Init
5209 >      end
5210 > _ACEOF
5211 > if ac_fn_fc_try_link "$LINENO"; then :
5212 >  ac_cv_lib_mpich_MPI_Init=yes
5213 > else
5214 >  ac_cv_lib_mpich_MPI_Init=no
5215 > fi
5216 > rm -f core conftest.err conftest.$ac_objext \
5217 >    conftest$ac_exeext conftest.$ac_ext
5218 > LIBS=$ac_check_lib_save_LIBS
5219 > fi
5220 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
5221 > $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
5222 > if test "x$ac_cv_lib_mpich_MPI_Init" = x""yes; then :
5223 >  MPILIBS="-lmpich"
5224 > fi
5225 >
5226 > fi
5227 >
5228 > if test x != x"$MPILIBS"; then
5229 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpif.h" >&5
5230 > $as_echo_n "checking for mpif.h... " >&6; }
5231 >        cat > conftest.$ac_ext <<_ACEOF
5232 >      program main
5233 >      include 'mpif.h'
5234 >      end
5235 > _ACEOF
5236 > if ac_fn_fc_try_compile "$LINENO"; then :
5237 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
5238 > $as_echo "yes" >&6; }
5239 > else
5240 >  MPILIBS=""
5241 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5242 > $as_echo "no" >&6; }
5243 > fi
5244 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5245 > fi
5246 >
5247 > FC="$ax_mpi_save_FC"
5248 >
5249 >
5250 >
5251 > # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
5252 > if test x = x"$MPILIBS"; then
5253 >        USE_MPI="no"
5254 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable Fortran MPI implementation found. oopse_MPI will not be built." >&5
5255 > $as_echo "$as_me: WARNING: No suitable Fortran MPI implementation found. oopse_MPI will not be built." >&2;}
5256 >        :
5257 > else
5258 >        USE_MPI="yes"
5259 >        :
5260 > fi
5261 >
5262 >
5263 > fi
5264 > if test $USE_MPI != no; then :
5265 >
5266 >        CXX=$MPICXX
5267 >        CC=$MPICC
5268 >        FC=$MPIFC
5269 >
5270 > fi
5271 >
5272 >
5273 > # Checks for programs.
5274 > ac_ext=cpp
5275 > ac_cpp='$CXXCPP $CPPFLAGS'
5276 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5277 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5278 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5279 > if test -z "$CXX"; then
5280 >  if test -n "$CCC"; then
5281 >    CXX=$CCC
5282 >  else
5283 >    if test -n "$ac_tool_prefix"; then
5284 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5285 >  do
5286 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5287 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5288 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5289 > $as_echo_n "checking for $ac_word... " >&6; }
5290 > if test "${ac_cv_prog_CXX+set}" = set; then :
5291 >  $as_echo_n "(cached) " >&6
5292 > else
5293 >  if test -n "$CXX"; then
5294 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
5295 > else
5296 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5297 > for as_dir in $PATH
5298 > do
5299 >  IFS=$as_save_IFS
5300 >  test -z "$as_dir" && as_dir=.
5301 >    for ac_exec_ext in '' $ac_executable_extensions; do
5302 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5303 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
5304 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5305 >    break 2
5306 >  fi
5307 > done
5308 >  done
5309 > IFS=$as_save_IFS
5310 >
5311 > fi
5312 > fi
5313 > CXX=$ac_cv_prog_CXX
5314 > if test -n "$CXX"; then
5315 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
5316 > $as_echo "$CXX" >&6; }
5317 > else
5318 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5319 > $as_echo "no" >&6; }
5320 > fi
5321 >
5322 >
5323 >    test -n "$CXX" && break
5324 >  done
5325 > fi
5326 > if test -z "$CXX"; then
5327 >  ac_ct_CXX=$CXX
5328 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
5329 > do
5330 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
5331 > set dummy $ac_prog; ac_word=$2
5332 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5333 > $as_echo_n "checking for $ac_word... " >&6; }
5334 > if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then :
5335 >  $as_echo_n "(cached) " >&6
5336 > else
5337 >  if test -n "$ac_ct_CXX"; then
5338 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
5339 > else
5340 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5341 > for as_dir in $PATH
5342 > do
5343 >  IFS=$as_save_IFS
5344 >  test -z "$as_dir" && as_dir=.
5345 >    for ac_exec_ext in '' $ac_executable_extensions; do
5346 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5347 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
5348 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5349 >    break 2
5350 >  fi
5351 > done
5352 >  done
5353 > IFS=$as_save_IFS
5354 >
5355 > fi
5356 > fi
5357 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
5358 > if test -n "$ac_ct_CXX"; then
5359 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
5360 > $as_echo "$ac_ct_CXX" >&6; }
5361 > else
5362 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5363 > $as_echo "no" >&6; }
5364 > fi
5365 >
5366 >
5367 >  test -n "$ac_ct_CXX" && break
5368 > done
5369 >
5370 >  if test "x$ac_ct_CXX" = x; then
5371 >    CXX="g++"
5372 >  else
5373 >    case $cross_compiling:$ac_tool_warned in
5374 > yes:)
5375 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5376 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5377 > ac_tool_warned=yes ;;
5378 > esac
5379 >    CXX=$ac_ct_CXX
5380 >  fi
5381 > fi
5382 >
5383 >  fi
5384 > fi
5385 > # Provide some information about the compiler.
5386 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
5387 > set X $ac_compile
5388 > ac_compiler=$2
5389 > for ac_option in --version -v -V -qversion; do
5390 >  { { ac_try="$ac_compiler $ac_option >&5"
5391 > case "(($ac_try" in
5392 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5393 >  *) ac_try_echo=$ac_try;;
5394 > esac
5395 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5396 > $as_echo "$ac_try_echo"; } >&5
5397 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
5398 >  ac_status=$?
5399 >  if test -s conftest.err; then
5400 >    sed '10a\
5401 > ... rest of stderr output deleted ...
5402 >         10q' conftest.err >conftest.er1
5403 >    cat conftest.er1 >&5
5404 >    rm -f conftest.er1 conftest.err
5405 >  fi
5406 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
5407 >  test $ac_status = 0; }
5408 > done
5409 >
5410 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
5411 > $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
5412 > if test "${ac_cv_cxx_compiler_gnu+set}" = set; then :
5413 >  $as_echo_n "(cached) " >&6
5414 > else
5415 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5416 > /* end confdefs.h.  */
5417 >
5418 > int
5419 > main ()
5420 > {
5421 > #ifndef __GNUC__
5422 >       choke me
5423 > #endif
5424 >
5425 >  ;
5426 >  return 0;
5427 > }
5428 > _ACEOF
5429 > if ac_fn_cxx_try_compile "$LINENO"; then :
5430 >  ac_compiler_gnu=yes
5431 > else
5432 >  ac_compiler_gnu=no
5433 > fi
5434 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5435 > ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
5436 >
5437 > fi
5438 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
5439 > $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
5440 > if test $ac_compiler_gnu = yes; then
5441 >  GXX=yes
5442 > else
5443 >  GXX=
5444 > fi
5445 > ac_test_CXXFLAGS=${CXXFLAGS+set}
5446 > ac_save_CXXFLAGS=$CXXFLAGS
5447 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
5448 > $as_echo_n "checking whether $CXX accepts -g... " >&6; }
5449 > if test "${ac_cv_prog_cxx_g+set}" = set; then :
5450 >  $as_echo_n "(cached) " >&6
5451 > else
5452 >  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
5453 >   ac_cxx_werror_flag=yes
5454 >   ac_cv_prog_cxx_g=no
5455 >   CXXFLAGS="-g"
5456 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5457 > /* end confdefs.h.  */
5458 >
5459 > int
5460 > main ()
5461 > {
5462 >
5463 >  ;
5464 >  return 0;
5465 > }
5466 > _ACEOF
5467 > if ac_fn_cxx_try_compile "$LINENO"; then :
5468 >  ac_cv_prog_cxx_g=yes
5469 > else
5470 >  CXXFLAGS=""
5471 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5472 > /* end confdefs.h.  */
5473 >
5474 > int
5475 > main ()
5476 > {
5477 >
5478 >  ;
5479 >  return 0;
5480 > }
5481 > _ACEOF
5482 > if ac_fn_cxx_try_compile "$LINENO"; then :
5483 >
5484 > else
5485 >  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
5486 >         CXXFLAGS="-g"
5487 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5488 > /* end confdefs.h.  */
5489 >
5490 > int
5491 > main ()
5492 > {
5493 >
5494 >  ;
5495 >  return 0;
5496 > }
5497 > _ACEOF
5498 > if ac_fn_cxx_try_compile "$LINENO"; then :
5499 >  ac_cv_prog_cxx_g=yes
5500 > fi
5501 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5502 > fi
5503 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5504 > fi
5505 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5506 >   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
5507 > fi
5508 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
5509 > $as_echo "$ac_cv_prog_cxx_g" >&6; }
5510 > if test "$ac_test_CXXFLAGS" = set; then
5511 >  CXXFLAGS=$ac_save_CXXFLAGS
5512 > elif test $ac_cv_prog_cxx_g = yes; then
5513 >  if test "$GXX" = yes; then
5514 >    CXXFLAGS="-g -O2"
5515 >  else
5516 >    CXXFLAGS="-g"
5517 >  fi
5518 > else
5519 >  if test "$GXX" = yes; then
5520 >    CXXFLAGS="-O2"
5521 >  else
5522 >    CXXFLAGS=
5523 >  fi
5524 > fi
5525 > ac_ext=${ac_fc_srcext-f}
5526 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5527 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5528 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5529 >
5530 > ac_ext=c
5531 > ac_cpp='$CPP $CPPFLAGS'
5532 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5533 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5534 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5535 > if test -n "$ac_tool_prefix"; then
5536 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
5537 >  do
5538 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5539 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5540 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5541 > $as_echo_n "checking for $ac_word... " >&6; }
5542 > if test "${ac_cv_prog_CC+set}" = set; then :
5543 >  $as_echo_n "(cached) " >&6
5544 > else
5545 >  if test -n "$CC"; then
5546 >  ac_cv_prog_CC="$CC" # Let the user override the test.
5547 > else
5548 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5549 > for as_dir in $PATH
5550 > do
5551 >  IFS=$as_save_IFS
5552 >  test -z "$as_dir" && as_dir=.
5553 >    for ac_exec_ext in '' $ac_executable_extensions; do
5554 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5555 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
5556 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5557 >    break 2
5558 >  fi
5559 > done
5560 >  done
5561 > IFS=$as_save_IFS
5562 >
5563 > fi
5564 > fi
5565 > CC=$ac_cv_prog_CC
5566 > if test -n "$CC"; then
5567 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
5568 > $as_echo "$CC" >&6; }
5569 > else
5570 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5571 > $as_echo "no" >&6; }
5572 > fi
5573 >
5574 >
5575 >    test -n "$CC" && break
5576 >  done
5577 > fi
5578 > if test -z "$CC"; then
5579 >  ac_ct_CC=$CC
5580 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
5581 > do
5582 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
5583 > set dummy $ac_prog; ac_word=$2
5584 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5585 > $as_echo_n "checking for $ac_word... " >&6; }
5586 > if test "${ac_cv_prog_ac_ct_CC+set}" = set; then :
5587 >  $as_echo_n "(cached) " >&6
5588 > else
5589 >  if test -n "$ac_ct_CC"; then
5590 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
5591 > else
5592 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5593 > for as_dir in $PATH
5594 > do
5595 >  IFS=$as_save_IFS
5596 >  test -z "$as_dir" && as_dir=.
5597 >    for ac_exec_ext in '' $ac_executable_extensions; do
5598 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5599 >    ac_cv_prog_ac_ct_CC="$ac_prog"
5600 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5601 >    break 2
5602 >  fi
5603 > done
5604 >  done
5605 > IFS=$as_save_IFS
5606 >
5607 > fi
5608 > fi
5609 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
5610 > if test -n "$ac_ct_CC"; then
5611 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
5612 > $as_echo "$ac_ct_CC" >&6; }
5613 > else
5614 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5615 > $as_echo "no" >&6; }
5616 > fi
5617 >
5618 >
5619 >  test -n "$ac_ct_CC" && break
5620 > done
5621 >
5622 >  if test "x$ac_ct_CC" = x; then
5623 >    CC=""
5624 >  else
5625 >    case $cross_compiling:$ac_tool_warned in
5626 > yes:)
5627 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5628 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5629 > ac_tool_warned=yes ;;
5630 > esac
5631 >    CC=$ac_ct_CC
5632 >  fi
5633 > fi
5634 >
5635 >
5636 > test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5637 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5638 > as_fn_error "no acceptable C compiler found in \$PATH
5639 > See \`config.log' for more details." "$LINENO" 5; }
5640 >
5641 > # Provide some information about the compiler.
5642 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
5643 > set X $ac_compile
5644 > ac_compiler=$2
5645 > for ac_option in --version -v -V -qversion; do
5646 >  { { ac_try="$ac_compiler $ac_option >&5"
5647 > case "(($ac_try" in
5648 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5649 >  *) ac_try_echo=$ac_try;;
5650 > esac
5651 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5652 > $as_echo "$ac_try_echo"; } >&5
5653 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
5654 >  ac_status=$?
5655 >  if test -s conftest.err; then
5656 >    sed '10a\
5657 > ... rest of stderr output deleted ...
5658 >         10q' conftest.err >conftest.er1
5659 >    cat conftest.er1 >&5
5660 >    rm -f conftest.er1 conftest.err
5661 >  fi
5662 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
5663 >  test $ac_status = 0; }
5664 > done
5665 >
5666 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
5667 > $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
5668 > if test "${ac_cv_c_compiler_gnu+set}" = set; then :
5669 >  $as_echo_n "(cached) " >&6
5670 > else
5671 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5672 > /* end confdefs.h.  */
5673 >
5674 > int
5675 > main ()
5676 > {
5677 > #ifndef __GNUC__
5678 >       choke me
5679 > #endif
5680 >
5681 >  ;
5682 >  return 0;
5683 > }
5684 > _ACEOF
5685 > if ac_fn_c_try_compile "$LINENO"; then :
5686 >  ac_compiler_gnu=yes
5687 > else
5688 >  ac_compiler_gnu=no
5689 > fi
5690 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5691 > ac_cv_c_compiler_gnu=$ac_compiler_gnu
5692 >
5693 > fi
5694 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
5695 > $as_echo "$ac_cv_c_compiler_gnu" >&6; }
5696 > if test $ac_compiler_gnu = yes; then
5697 >  GCC=yes
5698 > else
5699 >  GCC=
5700 > fi
5701 > ac_test_CFLAGS=${CFLAGS+set}
5702 > ac_save_CFLAGS=$CFLAGS
5703 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
5704 > $as_echo_n "checking whether $CC accepts -g... " >&6; }
5705 > if test "${ac_cv_prog_cc_g+set}" = set; then :
5706 >  $as_echo_n "(cached) " >&6
5707 > else
5708 >  ac_save_c_werror_flag=$ac_c_werror_flag
5709 >   ac_c_werror_flag=yes
5710 >   ac_cv_prog_cc_g=no
5711 >   CFLAGS="-g"
5712 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5713 > /* end confdefs.h.  */
5714 >
5715 > int
5716 > main ()
5717 > {
5718 >
5719 >  ;
5720 >  return 0;
5721 > }
5722 > _ACEOF
5723 > if ac_fn_c_try_compile "$LINENO"; then :
5724 >  ac_cv_prog_cc_g=yes
5725 > else
5726 >  CFLAGS=""
5727 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5728 > /* end confdefs.h.  */
5729 >
5730 > int
5731 > main ()
5732 > {
5733 >
5734 >  ;
5735 >  return 0;
5736 > }
5737 > _ACEOF
5738 > if ac_fn_c_try_compile "$LINENO"; then :
5739 >
5740 > else
5741 >  ac_c_werror_flag=$ac_save_c_werror_flag
5742 >         CFLAGS="-g"
5743 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5744 > /* end confdefs.h.  */
5745 >
5746 > int
5747 > main ()
5748 > {
5749 >
5750 >  ;
5751 >  return 0;
5752 > }
5753 > _ACEOF
5754 > if ac_fn_c_try_compile "$LINENO"; then :
5755 >  ac_cv_prog_cc_g=yes
5756 > fi
5757 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5758 > fi
5759 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5760 > fi
5761 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5762 >   ac_c_werror_flag=$ac_save_c_werror_flag
5763 > fi
5764 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
5765 > $as_echo "$ac_cv_prog_cc_g" >&6; }
5766 > if test "$ac_test_CFLAGS" = set; then
5767 >  CFLAGS=$ac_save_CFLAGS
5768 > elif test $ac_cv_prog_cc_g = yes; then
5769 >  if test "$GCC" = yes; then
5770 >    CFLAGS="-g -O2"
5771 >  else
5772 >    CFLAGS="-g"
5773 >  fi
5774 > else
5775 >  if test "$GCC" = yes; then
5776 >    CFLAGS="-O2"
5777 >  else
5778 >    CFLAGS=
5779 >  fi
5780 > fi
5781 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
5782 > $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
5783 > if test "${ac_cv_prog_cc_c89+set}" = set; then :
5784 >  $as_echo_n "(cached) " >&6
5785 > else
5786 >  ac_cv_prog_cc_c89=no
5787 > ac_save_CC=$CC
5788 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5789 > /* end confdefs.h.  */
5790 > #include <stdarg.h>
5791 > #include <stdio.h>
5792 > #include <sys/types.h>
5793 > #include <sys/stat.h>
5794 > /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
5795 > struct buf { int x; };
5796 > FILE * (*rcsopen) (struct buf *, struct stat *, int);
5797 > static char *e (p, i)
5798 >     char **p;
5799 >     int i;
5800 > {
5801 >  return p[i];
5802 > }
5803 > static char *f (char * (*g) (char **, int), char **p, ...)
5804 > {
5805 >  char *s;
5806 >  va_list v;
5807 >  va_start (v,p);
5808 >  s = g (p, va_arg (v,int));
5809 >  va_end (v);
5810 >  return s;
5811 > }
5812 >
5813 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
5814 >   function prototypes and stuff, but not '\xHH' hex character constants.
5815 >   These don't provoke an error unfortunately, instead are silently treated
5816 >   as 'x'.  The following induces an error, until -std is added to get
5817 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
5818 >   array size at least.  It's necessary to write '\x00'==0 to get something
5819 >   that's true only with -std.  */
5820 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
5821 >
5822 > /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
5823 >   inside strings and character constants.  */
5824 > #define FOO(x) 'x'
5825 > int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
5826 >
5827 > int test (int i, double x);
5828 > struct s1 {int (*f) (int a);};
5829 > struct s2 {int (*f) (double a);};
5830 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
5831 > int argc;
5832 > char **argv;
5833 > int
5834 > main ()
5835 > {
5836 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
5837 >  ;
5838 >  return 0;
5839 > }
5840 > _ACEOF
5841 > for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
5842 >        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
5843 > do
5844 >  CC="$ac_save_CC $ac_arg"
5845 >  if ac_fn_c_try_compile "$LINENO"; then :
5846 >  ac_cv_prog_cc_c89=$ac_arg
5847 > fi
5848 > rm -f core conftest.err conftest.$ac_objext
5849 >  test "x$ac_cv_prog_cc_c89" != "xno" && break
5850 > done
5851 > rm -f conftest.$ac_ext
5852 > CC=$ac_save_CC
5853 >
5854 > fi
5855 > # AC_CACHE_VAL
5856 > case "x$ac_cv_prog_cc_c89" in
5857 >  x)
5858 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
5859 > $as_echo "none needed" >&6; } ;;
5860 >  xno)
5861 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
5862 > $as_echo "unsupported" >&6; } ;;
5863 >  *)
5864 >    CC="$CC $ac_cv_prog_cc_c89"
5865 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
5866 > $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
5867 > esac
5868 > if test "x$ac_cv_prog_cc_c89" != xno; then :
5869 >
5870 > fi
5871 >
5872 > ac_ext=${ac_fc_srcext-f}
5873 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5874 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5875 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5876 >
5877 > ac_ext=${ac_fc_srcext-f}
5878 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5879 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5880 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5881 > if test -n "$ac_tool_prefix"; then
5882 >  for ac_prog in $FC ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
5883 >  do
5884 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
5885 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
5886 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5887 > $as_echo_n "checking for $ac_word... " >&6; }
5888 > if test "${ac_cv_prog_FC+set}" = set; then :
5889 >  $as_echo_n "(cached) " >&6
5890 > else
5891 >  if test -n "$FC"; then
5892 >  ac_cv_prog_FC="$FC" # Let the user override the test.
5893 > else
5894 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5895 > for as_dir in $PATH
5896 > do
5897 >  IFS=$as_save_IFS
5898 >  test -z "$as_dir" && as_dir=.
5899 >    for ac_exec_ext in '' $ac_executable_extensions; do
5900 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5901 >    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
5902 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5903 >    break 2
5904 >  fi
5905 > done
5906 >  done
5907 > IFS=$as_save_IFS
5908 >
5909 > fi
5910 > fi
5911 > FC=$ac_cv_prog_FC
5912 > if test -n "$FC"; then
5913 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FC" >&5
5914 > $as_echo "$FC" >&6; }
5915 > else
5916 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5917 > $as_echo "no" >&6; }
5918 > fi
5919 >
5920 >
5921 >    test -n "$FC" && break
5922 >  done
5923 > fi
5924 > if test -z "$FC"; then
5925 >  ac_ct_FC=$FC
5926 >  for ac_prog in $FC ifort ifc pathf95 pgf95 xlf95 lf95 epcf90 pathf90 xlf90 f95 f90 gfortran g95 fort
5927 > do
5928 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
5929 > set dummy $ac_prog; ac_word=$2
5930 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
5931 > $as_echo_n "checking for $ac_word... " >&6; }
5932 > if test "${ac_cv_prog_ac_ct_FC+set}" = set; then :
5933 >  $as_echo_n "(cached) " >&6
5934 > else
5935 >  if test -n "$ac_ct_FC"; then
5936 >  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
5937 > else
5938 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5939 > for as_dir in $PATH
5940 > do
5941 >  IFS=$as_save_IFS
5942 >  test -z "$as_dir" && as_dir=.
5943 >    for ac_exec_ext in '' $ac_executable_extensions; do
5944 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5945 >    ac_cv_prog_ac_ct_FC="$ac_prog"
5946 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5947 >    break 2
5948 >  fi
5949 > done
5950 >  done
5951 > IFS=$as_save_IFS
5952 >
5953 > fi
5954 > fi
5955 > ac_ct_FC=$ac_cv_prog_ac_ct_FC
5956 > if test -n "$ac_ct_FC"; then
5957 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_FC" >&5
5958 > $as_echo "$ac_ct_FC" >&6; }
5959 > else
5960 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5961 > $as_echo "no" >&6; }
5962 > fi
5963 >
5964 >
5965 >  test -n "$ac_ct_FC" && break
5966 > done
5967 >
5968 >  if test "x$ac_ct_FC" = x; then
5969 >    FC=""
5970 >  else
5971 >    case $cross_compiling:$ac_tool_warned in
5972 > yes:)
5973 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
5974 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
5975 > ac_tool_warned=yes ;;
5976 > esac
5977 >    FC=$ac_ct_FC
5978 >  fi
5979 > fi
5980 >
5981 >
5982 > # Provide some information about the compiler.
5983 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran compiler version" >&5
5984 > set X $ac_compile
5985 > ac_compiler=$2
5986 > for ac_option in --version -v -V -qversion; do
5987 >  { { ac_try="$ac_compiler $ac_option >&5"
5988 > case "(($ac_try" in
5989 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5990 >  *) ac_try_echo=$ac_try;;
5991 > esac
5992 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
5993 > $as_echo "$ac_try_echo"; } >&5
5994 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
5995 >  ac_status=$?
5996 >  if test -s conftest.err; then
5997 >    sed '10a\
5998 > ... rest of stderr output deleted ...
5999 >         10q' conftest.err >conftest.er1
6000 >    cat conftest.er1 >&5
6001 >    rm -f conftest.er1 conftest.err
6002 >  fi
6003 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6004 >  test $ac_status = 0; }
6005 > done
6006 > rm -f a.out
6007 >
6008 > # If we don't use `.F' as extension, the preprocessor is not run on the
6009 > # input file.  (Note that this only needs to work for GNU compilers.)
6010 > ac_save_ext=$ac_ext
6011 > ac_ext=F
6012 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Fortran compiler" >&5
6013 > $as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
6014 > if test "${ac_cv_fc_compiler_gnu+set}" = set; then :
6015 >  $as_echo_n "(cached) " >&6
6016 > else
6017 >  cat > conftest.$ac_ext <<_ACEOF
6018 >      program main
6019 > #ifndef __GNUC__
6020 >       choke me
6021 > #endif
6022 >
6023 >      end
6024 > _ACEOF
6025 > if ac_fn_fc_try_compile "$LINENO"; then :
6026 >  ac_compiler_gnu=yes
6027 > else
6028 >  ac_compiler_gnu=no
6029 > fi
6030 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6031 > ac_cv_fc_compiler_gnu=$ac_compiler_gnu
6032 >
6033 > fi
6034 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_compiler_gnu" >&5
6035 > $as_echo "$ac_cv_fc_compiler_gnu" >&6; }
6036 > ac_ext=$ac_save_ext
6037 > ac_test_FCFLAGS=${FCFLAGS+set}
6038 > ac_save_FCFLAGS=$FCFLAGS
6039 > FCFLAGS=
6040 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $FC accepts -g" >&5
6041 > $as_echo_n "checking whether $FC accepts -g... " >&6; }
6042 > if test "${ac_cv_prog_fc_g+set}" = set; then :
6043 >  $as_echo_n "(cached) " >&6
6044 > else
6045 >  FCFLAGS=-g
6046 > cat > conftest.$ac_ext <<_ACEOF
6047 >      program main
6048 >
6049 >      end
6050 > _ACEOF
6051 > if ac_fn_fc_try_compile "$LINENO"; then :
6052 >  ac_cv_prog_fc_g=yes
6053 > else
6054 >  ac_cv_prog_fc_g=no
6055 > fi
6056 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6057 >
6058 > fi
6059 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_g" >&5
6060 > $as_echo "$ac_cv_prog_fc_g" >&6; }
6061 > if test "$ac_test_FCFLAGS" = set; then
6062 >  FCFLAGS=$ac_save_FCFLAGS
6063 > elif test $ac_cv_prog_fc_g = yes; then
6064 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
6065 >    FCFLAGS="-g -O2"
6066 >  else
6067 >    FCFLAGS="-g"
6068 >  fi
6069 > else
6070 >  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
6071 >    FCFLAGS="-O2"
6072 >  else
6073 >    FCFLAGS=
6074 >  fi
6075 > fi
6076 >
6077 > ac_ext=${ac_fc_srcext-f}
6078 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6079 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6080 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6081 >
6082 > ac_ext=c
6083 > ac_cpp='$CPP $CPPFLAGS'
6084 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6085 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6086 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
6087 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
6088 > $as_echo_n "checking how to run the C preprocessor... " >&6; }
6089 > # On Suns, sometimes $CPP names a directory.
6090 > if test -n "$CPP" && test -d "$CPP"; then
6091 >  CPP=
6092 > fi
6093 > if test -z "$CPP"; then
6094 >  if test "${ac_cv_prog_CPP+set}" = set; then :
6095 >  $as_echo_n "(cached) " >&6
6096 > else
6097 >      # Double quotes because CPP needs to be expanded
6098 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
6099 >    do
6100 >      ac_preproc_ok=false
6101 > for ac_c_preproc_warn_flag in '' yes
6102 > do
6103 >  # Use a header file that comes with gcc, so configuring glibc
6104 >  # with a fresh cross-compiler works.
6105 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6106 >  # <limits.h> exists even on freestanding compilers.
6107 >  # On the NeXT, cc -E runs the code through the compiler's parser,
6108 >  # not just through cpp. "Syntax error" is here to catch this case.
6109 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6110 > /* end confdefs.h.  */
6111 > #ifdef __STDC__
6112 > # include <limits.h>
6113 > #else
6114 > # include <assert.h>
6115 > #endif
6116 >                     Syntax error
6117 > _ACEOF
6118 > if ac_fn_c_try_cpp "$LINENO"; then :
6119 >
6120 > else
6121 >  # Broken: fails on valid input.
6122 > continue
6123 > fi
6124 > rm -f conftest.err conftest.$ac_ext
6125 >
6126 >  # OK, works on sane cases.  Now check whether nonexistent headers
6127 >  # can be detected and how.
6128 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6129 > /* end confdefs.h.  */
6130 > #include <ac_nonexistent.h>
6131 > _ACEOF
6132 > if ac_fn_c_try_cpp "$LINENO"; then :
6133 >  # Broken: success on invalid input.
6134 > continue
6135 > else
6136 >  # Passes both tests.
6137 > ac_preproc_ok=:
6138 > break
6139 > fi
6140 > rm -f conftest.err conftest.$ac_ext
6141 >
6142 > done
6143 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
6144 > rm -f conftest.err conftest.$ac_ext
6145 > if $ac_preproc_ok; then :
6146 >  break
6147 > fi
6148 >
6149 >    done
6150 >    ac_cv_prog_CPP=$CPP
6151 >
6152 > fi
6153 >  CPP=$ac_cv_prog_CPP
6154 > else
6155 >  ac_cv_prog_CPP=$CPP
6156 > fi
6157 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
6158 > $as_echo "$CPP" >&6; }
6159 > ac_preproc_ok=false
6160 > for ac_c_preproc_warn_flag in '' yes
6161 > do
6162 >  # Use a header file that comes with gcc, so configuring glibc
6163 >  # with a fresh cross-compiler works.
6164 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
6165 >  # <limits.h> exists even on freestanding compilers.
6166 >  # On the NeXT, cc -E runs the code through the compiler's parser,
6167 >  # not just through cpp. "Syntax error" is here to catch this case.
6168 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6169 > /* end confdefs.h.  */
6170 > #ifdef __STDC__
6171 > # include <limits.h>
6172 > #else
6173 > # include <assert.h>
6174 > #endif
6175 >                     Syntax error
6176 > _ACEOF
6177 > if ac_fn_c_try_cpp "$LINENO"; then :
6178 >
6179 > else
6180 >  # Broken: fails on valid input.
6181 > continue
6182 > fi
6183 > rm -f conftest.err conftest.$ac_ext
6184 >
6185 >  # OK, works on sane cases.  Now check whether nonexistent headers
6186 >  # can be detected and how.
6187 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6188 > /* end confdefs.h.  */
6189 > #include <ac_nonexistent.h>
6190 > _ACEOF
6191 > if ac_fn_c_try_cpp "$LINENO"; then :
6192 >  # Broken: success on invalid input.
6193 > continue
6194 > else
6195 >  # Passes both tests.
6196 > ac_preproc_ok=:
6197 > break
6198 > fi
6199 > rm -f conftest.err conftest.$ac_ext
6200 >
6201 > done
6202 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
6203 > rm -f conftest.err conftest.$ac_ext
6204 > if $ac_preproc_ok; then :
6205 >
6206 > else
6207 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
6208 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
6209 > as_fn_error "C preprocessor \"$CPP\" fails sanity check
6210 > See \`config.log' for more details." "$LINENO" 5; }
6211 > fi
6212 >
6213 > ac_ext=${ac_fc_srcext-f}
6214 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6215 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6216 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6217 >
6218 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
6219 > $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
6220 > if test "${ac_cv_path_GREP+set}" = set; then :
6221 >  $as_echo_n "(cached) " >&6
6222 > else
6223 >  if test -z "$GREP"; then
6224 >  ac_path_GREP_found=false
6225 >  # Loop through the user's path and test for each of PROGNAME-LIST
6226 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6227 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
6228 > do
6229 >  IFS=$as_save_IFS
6230 >  test -z "$as_dir" && as_dir=.
6231 >    for ac_prog in grep ggrep; do
6232 >    for ac_exec_ext in '' $ac_executable_extensions; do
6233 >      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
6234 >      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
6235 > # Check for GNU ac_path_GREP and select it if it is found.
6236 >  # Check for GNU $ac_path_GREP
6237 > case `"$ac_path_GREP" --version 2>&1` in
6238 > *GNU*)
6239 >  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
6240 > *)
6241 >  ac_count=0
6242 >  $as_echo_n 0123456789 >"conftest.in"
6243 >  while :
6244 >  do
6245 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
6246 >    mv "conftest.tmp" "conftest.in"
6247 >    cp "conftest.in" "conftest.nl"
6248 >    $as_echo 'GREP' >> "conftest.nl"
6249 >    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
6250 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
6251 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
6252 >    if test $ac_count -gt ${ac_path_GREP_max-0}; then
6253 >      # Best one so far, save it but keep looking for a better one
6254 >      ac_cv_path_GREP="$ac_path_GREP"
6255 >      ac_path_GREP_max=$ac_count
6256 >    fi
6257 >    # 10*(2^10) chars as input seems more than enough
6258 >    test $ac_count -gt 10 && break
6259 >  done
6260 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
6261 > esac
6262 >
6263 >      $ac_path_GREP_found && break 3
6264 >    done
6265 >  done
6266 >  done
6267 > IFS=$as_save_IFS
6268 >  if test -z "$ac_cv_path_GREP"; then
6269 >    as_fn_error "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6270 >  fi
6271 > else
6272 >  ac_cv_path_GREP=$GREP
6273 > fi
6274 >
6275 > fi
6276 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
6277 > $as_echo "$ac_cv_path_GREP" >&6; }
6278 > GREP="$ac_cv_path_GREP"
6279 >
6280 >
6281 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
6282 > $as_echo_n "checking for egrep... " >&6; }
6283 > if test "${ac_cv_path_EGREP+set}" = set; then :
6284 >  $as_echo_n "(cached) " >&6
6285 > else
6286 >  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
6287 >   then ac_cv_path_EGREP="$GREP -E"
6288 >   else
6289 >     if test -z "$EGREP"; then
6290 >  ac_path_EGREP_found=false
6291 >  # Loop through the user's path and test for each of PROGNAME-LIST
6292 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6293 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
6294 > do
6295 >  IFS=$as_save_IFS
6296 >  test -z "$as_dir" && as_dir=.
6297 >    for ac_prog in egrep; do
6298 >    for ac_exec_ext in '' $ac_executable_extensions; do
6299 >      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
6300 >      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
6301 > # Check for GNU ac_path_EGREP and select it if it is found.
6302 >  # Check for GNU $ac_path_EGREP
6303 > case `"$ac_path_EGREP" --version 2>&1` in
6304 > *GNU*)
6305 >  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
6306 > *)
6307 >  ac_count=0
6308 >  $as_echo_n 0123456789 >"conftest.in"
6309 >  while :
6310 >  do
6311 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
6312 >    mv "conftest.tmp" "conftest.in"
6313 >    cp "conftest.in" "conftest.nl"
6314 >    $as_echo 'EGREP' >> "conftest.nl"
6315 >    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
6316 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
6317 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
6318 >    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
6319 >      # Best one so far, save it but keep looking for a better one
6320 >      ac_cv_path_EGREP="$ac_path_EGREP"
6321 >      ac_path_EGREP_max=$ac_count
6322 >    fi
6323 >    # 10*(2^10) chars as input seems more than enough
6324 >    test $ac_count -gt 10 && break
6325 >  done
6326 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
6327 > esac
6328 >
6329 >      $ac_path_EGREP_found && break 3
6330 >    done
6331 >  done
6332 >  done
6333 > IFS=$as_save_IFS
6334 >  if test -z "$ac_cv_path_EGREP"; then
6335 >    as_fn_error "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
6336 >  fi
6337 > else
6338 >  ac_cv_path_EGREP=$EGREP
6339 > fi
6340 >
6341 >   fi
6342 > fi
6343 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
6344 > $as_echo "$ac_cv_path_EGREP" >&6; }
6345 > EGREP="$ac_cv_path_EGREP"
6346 >
6347 >
6348 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
6349 > $as_echo_n "checking whether ln -s works... " >&6; }
6350 > LN_S=$as_ln_s
6351 > if test "$LN_S" = "ln -s"; then
6352 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6353 > $as_echo "yes" >&6; }
6354 > else
6355 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
6356 > $as_echo "no, using $LN_S" >&6; }
6357 > fi
6358 >
6359 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
6360 > $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
6361 > set x ${MAKE-make}
6362 > ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
6363 > if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then :
6364 >  $as_echo_n "(cached) " >&6
6365 > else
6366 >  cat >conftest.make <<\_ACEOF
6367 > SHELL = /bin/sh
6368 > all:
6369 >        @echo '@@@%%%=$(MAKE)=@@@%%%'
6370 > _ACEOF
6371 > # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
6372 > case `${MAKE-make} -f conftest.make 2>/dev/null` in
6373 >  *@@@%%%=?*=@@@%%%*)
6374 >    eval ac_cv_prog_make_${ac_make}_set=yes;;
6375 >  *)
6376 >    eval ac_cv_prog_make_${ac_make}_set=no;;
6377 > esac
6378 > rm -f conftest.make
6379 > fi
6380 > if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
6381 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6382 > $as_echo "yes" >&6; }
6383 >  SET_MAKE=
6384 > else
6385 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6386 > $as_echo "no" >&6; }
6387 >  SET_MAKE="MAKE=${MAKE-make}"
6388 > fi
6389 >
6390 > if test -n "$ac_tool_prefix"; then
6391 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6392 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6393 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6394 > $as_echo_n "checking for $ac_word... " >&6; }
6395 > if test "${ac_cv_prog_RANLIB+set}" = set; then :
6396 >  $as_echo_n "(cached) " >&6
6397 > else
6398 >  if test -n "$RANLIB"; then
6399 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6400 > else
6401 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6402 > for as_dir in $PATH
6403 > do
6404 >  IFS=$as_save_IFS
6405 >  test -z "$as_dir" && as_dir=.
6406 >    for ac_exec_ext in '' $ac_executable_extensions; do
6407 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6408 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6409 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6410 >    break 2
6411 >  fi
6412 > done
6413 >  done
6414 > IFS=$as_save_IFS
6415 >
6416 > fi
6417 > fi
6418 > RANLIB=$ac_cv_prog_RANLIB
6419 > if test -n "$RANLIB"; then
6420 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
6421 > $as_echo "$RANLIB" >&6; }
6422 > else
6423 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6424 > $as_echo "no" >&6; }
6425 > fi
6426 >
6427 >
6428 > fi
6429 > if test -z "$ac_cv_prog_RANLIB"; then
6430 >  ac_ct_RANLIB=$RANLIB
6431 >  # Extract the first word of "ranlib", so it can be a program name with args.
6432 > set dummy ranlib; ac_word=$2
6433 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6434 > $as_echo_n "checking for $ac_word... " >&6; }
6435 > if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then :
6436 >  $as_echo_n "(cached) " >&6
6437 > else
6438 >  if test -n "$ac_ct_RANLIB"; then
6439 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6440 > else
6441 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6442 > for as_dir in $PATH
6443 > do
6444 >  IFS=$as_save_IFS
6445 >  test -z "$as_dir" && as_dir=.
6446 >    for ac_exec_ext in '' $ac_executable_extensions; do
6447 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6448 >    ac_cv_prog_ac_ct_RANLIB="ranlib"
6449 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6450 >    break 2
6451 >  fi
6452 > done
6453 >  done
6454 > IFS=$as_save_IFS
6455 >
6456 > fi
6457 > fi
6458 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6459 > if test -n "$ac_ct_RANLIB"; then
6460 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
6461 > $as_echo "$ac_ct_RANLIB" >&6; }
6462 > else
6463 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6464 > $as_echo "no" >&6; }
6465 > fi
6466 >
6467 >  if test "x$ac_ct_RANLIB" = x; then
6468 >    RANLIB=":"
6469 >  else
6470 >    case $cross_compiling:$ac_tool_warned in
6471 > yes:)
6472 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
6473 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
6474 > ac_tool_warned=yes ;;
6475 > esac
6476 >    RANLIB=$ac_ct_RANLIB
6477 >  fi
6478 > else
6479 >  RANLIB="$ac_cv_prog_RANLIB"
6480 > fi
6481 >
6482 >
6483 >   # Extract the first word of "perl", so it can be a program name with args.
6484 > set dummy perl; ac_word=$2
6485 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6486 > $as_echo_n "checking for $ac_word... " >&6; }
6487 > if test "${ac_cv_path_PERLINTERP+set}" = set; then :
6488 >  $as_echo_n "(cached) " >&6
6489 > else
6490 >  case $PERLINTERP in
6491 >  [\\/]* | ?:[\\/]*)
6492 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
6493 >  ;;
6494 >  *)
6495 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6496 > for as_dir in $PATH
6497 > do
6498 >  IFS=$as_save_IFS
6499 >  test -z "$as_dir" && as_dir=.
6500 >    for ac_exec_ext in '' $ac_executable_extensions; do
6501 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6502 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
6503 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6504 >    break 2
6505 >  fi
6506 > done
6507 >  done
6508 > IFS=$as_save_IFS
6509 >
6510 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
6511 >  ;;
6512 > esac
6513 > fi
6514 > PERLINTERP=$ac_cv_path_PERLINTERP
6515 > if test -n "$PERLINTERP"; then
6516 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERLINTERP" >&5
6517 > $as_echo "$PERLINTERP" >&6; }
6518 > else
6519 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6520 > $as_echo "no" >&6; }
6521 > fi
6522 >
6523 >
6524 >   ac_cv_path_perlinterp="$PERLINTERP"
6525 >   _sHpB='#!'
6526 >
6527 >
6528 > # Check whether --with-perl-shebang was given.
6529 > if test "${with_perl_shebang+set}" = set; then :
6530 >  withval=$with_perl_shebang; opt_perl_shebang="$withval"
6531 > else
6532 >                opt_perl_shebang="not_set"
6533 > fi
6534 >
6535 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether explicit instead of detected sharpbang is to be used" >&5
6536 > $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
6537 > if test "${ax_cv_opt_perl_shebang+set}" = set; then :
6538 >  $as_echo_n "(cached) " >&6
6539 > else
6540 >   case "$opt_perl_shebang" in
6541 >                      not_set  ) ax_cv_opt_perl_shebang=''
6542 >                               ;;
6543 >                         *     )
6544 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
6545 >                    esac
6546 >
6547 > fi
6548 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_opt_perl_shebang" >&5
6549 > $as_echo "$ax_cv_opt_perl_shebang" >&6; }
6550 >   if test "A$ax_cv_opt_perl_shebang" != "A"
6551 >     then
6552 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
6553 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
6554 >              { $as_echo "$as_me:${as_lineno-$LINENO}: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
6555 > $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
6556 >
6557 > # Automatic detection of sharpbang formula starts here
6558 >     else
6559 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
6560 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
6561 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel sharpbang invocation to start perl" >&5
6562 > $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
6563 > if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then :
6564 >  $as_echo_n "(cached) " >&6
6565 > else
6566 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
6567 >        if test "x$_somian_kspb_perl" == x
6568 >          then _somian_ksbp_warn_empty='durnit'
6569 >          else
6570 >          case "A$_somian_kspb_perl" in
6571 >                 A#!*perl* )
6572 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
6573 >                        ;;
6574 >                     A*    )  _somian_ksbp_warn_defau='trouble'
6575 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
6576 >          esac
6577 >        fi
6578 >
6579 > fi
6580 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_kernshrpbang_perl" >&5
6581 > $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
6582 > # The above prints Checking ... result message to user.
6583 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
6584 >
6585 >    if test A${_somian_ksbp_warn_empty+set} == Aset
6586 >      then   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
6587 > $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
6588 >    fi
6589 > # Inform user after printing result value
6590 >    if test A${_somian_ksbp_warn_defau+set} == Aset
6591 >      then { $as_echo "$as_me:${as_lineno-$LINENO}: Maybe Not good -" >&5
6592 > $as_echo "$as_me: Maybe Not good -" >&6;}
6593 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
6594 > $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
6595 >      else { $as_echo "$as_me:${as_lineno-$LINENO}: OK Good result - " >&5
6596 > $as_echo "$as_me: OK Good result - " >&6;}
6597 >           { $as_echo "$as_me:${as_lineno-$LINENO}: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
6598 > $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
6599 >    fi
6600 >  fi
6601 >
6602 > # Find a good install program.  We prefer a C program (faster),
6603 > # so one script is as good as another.  But avoid the broken or
6604 > # incompatible versions:
6605 > # SysV /etc/install, /usr/sbin/install
6606 > # SunOS /usr/etc/install
6607 > # IRIX /sbin/install
6608 > # AIX /bin/install
6609 > # AmigaOS /C/install, which installs bootblocks on floppy discs
6610 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6611 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6612 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6613 > # OS/2's system install, which has a completely different semantic
6614 > # ./install, which can be erroneously created by make from ./install.sh.
6615 > # Reject install programs that cannot install multiple files.
6616 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
6617 > $as_echo_n "checking for a BSD-compatible install... " >&6; }
6618 > if test -z "$INSTALL"; then
6619 > if test "${ac_cv_path_install+set}" = set; then :
6620 >  $as_echo_n "(cached) " >&6
6621 > else
6622 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6623 > for as_dir in $PATH
6624 > do
6625 >  IFS=$as_save_IFS
6626 >  test -z "$as_dir" && as_dir=.
6627 >    # Account for people who put trailing slashes in PATH elements.
6628 > case $as_dir/ in #((
6629 >  ./ | .// | /[cC]/* | \
6630 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6631 >  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
6632 >  /usr/ucb/* ) ;;
6633 >  *)
6634 >    # OSF1 and SCO ODT 3.0 have their own names for install.
6635 >    # Don't use installbsd from OSF since it installs stuff as root
6636 >    # by default.
6637 >    for ac_prog in ginstall scoinst install; do
6638 >      for ac_exec_ext in '' $ac_executable_extensions; do
6639 >        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
6640 >          if test $ac_prog = install &&
6641 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6642 >            # AIX install.  It has an incompatible calling convention.
6643 >            :
6644 >          elif test $ac_prog = install &&
6645 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6646 >            # program-specific install script used by HP pwplus--don't use.
6647 >            :
6648 >          else
6649 >            rm -rf conftest.one conftest.two conftest.dir
6650 >            echo one > conftest.one
6651 >            echo two > conftest.two
6652 >            mkdir conftest.dir
6653 >            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
6654 >              test -s conftest.one && test -s conftest.two &&
6655 >              test -s conftest.dir/conftest.one &&
6656 >              test -s conftest.dir/conftest.two
6657 >            then
6658 >              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6659 >              break 3
6660 >            fi
6661 >          fi
6662 >        fi
6663 >      done
6664 >    done
6665 >    ;;
6666 > esac
6667 >
6668 >  done
6669 > IFS=$as_save_IFS
6670 >
6671 > rm -rf conftest.one conftest.two conftest.dir
6672 >
6673 > fi
6674 >  if test "${ac_cv_path_install+set}" = set; then
6675 >    INSTALL=$ac_cv_path_install
6676 >  else
6677 >    # As a last resort, use the slow shell script.  Don't cache a
6678 >    # value for INSTALL within a source directory, because that will
6679 >    # break other packages using the cache if that directory is
6680 >    # removed, or if the value is a relative name.
6681 >    INSTALL=$ac_install_sh
6682 >  fi
6683 > fi
6684 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
6685 > $as_echo "$INSTALL" >&6; }
6686 >
6687 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6688 > # It thinks the first close brace ends the variable substitution.
6689 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6690 >
6691 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6692 >
6693 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6694 >
6695 > case "x$INSTALL" in
6696 >   x/*) ;;
6697 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
6698 > esac
6699 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
6700 > # Extract the first word of "ar", so it can be a program name with args.
6701 > set dummy ar; ac_word=$2
6702 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6703 > $as_echo_n "checking for $ac_word... " >&6; }
6704 > if test "${ac_cv_prog_AR+set}" = set; then :
6705 >  $as_echo_n "(cached) " >&6
6706 > else
6707 >  if test -n "$AR"; then
6708 >  ac_cv_prog_AR="$AR" # Let the user override the test.
6709 > else
6710 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6711 > for as_dir in $PATH
6712 > do
6713 >  IFS=$as_save_IFS
6714 >  test -z "$as_dir" && as_dir=.
6715 >    for ac_exec_ext in '' $ac_executable_extensions; do
6716 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6717 >    ac_cv_prog_AR="ar"
6718 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6719 >    break 2
6720 >  fi
6721 > done
6722 >  done
6723 > IFS=$as_save_IFS
6724 >
6725 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
6726 > fi
6727 > fi
6728 > AR=$ac_cv_prog_AR
6729 > if test -n "$AR"; then
6730 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
6731 > $as_echo "$AR" >&6; }
6732 > else
6733 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6734 > $as_echo "no" >&6; }
6735 > fi
6736 >
6737 >
6738 > if test "$AR" = "NONE"; then
6739 >  cat >confcache <<\_ACEOF
6740 > # This file is a shell script that caches the results of configure
6741 > # tests run on this system so they can be shared between configure
6742 > # scripts and configure runs, see configure's option --config-cache.
6743 > # It is not useful on other systems.  If it contains results you don't
6744 > # want to keep, you may remove or edit it.
6745 > #
6746 > # config.status only pays attention to the cache file if you give it
6747 > # the --recheck option to rerun configure.
6748 > #
6749 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
6750 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
6751 > # following values.
6752 >
6753 > _ACEOF
6754 >
6755 > # The following way of writing the cache mishandles newlines in values,
6756 > # but we know of no workaround that is simple, portable, and efficient.
6757 > # So, we kill variables containing newlines.
6758 > # Ultrix sh set writes to stderr and can't be redirected directly,
6759 > # and sets the high bit in the cache file unless we assign to the vars.
6760 > (
6761 >  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
6762 >    eval ac_val=\$$ac_var
6763 >    case $ac_val in #(
6764 >    *${as_nl}*)
6765 >      case $ac_var in #(
6766 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
6767 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
6768 >      esac
6769 >      case $ac_var in #(
6770 >      _ | IFS | as_nl) ;; #(
6771 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
6772 >      *) { eval $ac_var=; unset $ac_var;} ;;
6773 >      esac ;;
6774 >    esac
6775 >  done
6776 >
6777 >  (set) 2>&1 |
6778 >    case $as_nl`(ac_space=' '; set) 2>&1` in #(
6779 >    *${as_nl}ac_space=\ *)
6780 >      # `set' does not quote correctly, so add quotes: double-quote
6781 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
6782 >      sed -n \
6783 >        "s/'/'\\\\''/g;
6784 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6785 >      ;; #(
6786 >    *)
6787 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
6788 >      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
6789 >      ;;
6790 >    esac |
6791 >    sort
6792 > ) |
6793 >  sed '
6794 >     /^ac_cv_env_/b end
6795 >     t clear
6796 >     :clear
6797 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6798 >     t end
6799 >     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6800 >     :end' >>confcache
6801 > if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
6802 >  if test -w "$cache_file"; then
6803 >    test "x$cache_file" != "x/dev/null" &&
6804 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
6805 > $as_echo "$as_me: updating cache $cache_file" >&6;}
6806 >    cat confcache >$cache_file
6807 >  else
6808 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
6809 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
6810 >  fi
6811 > fi
6812 > rm -f confcache
6813 >  exit 1
6814 > fi
6815 > # Extract the first word of "ps", so it can be a program name with args.
6816 > set dummy ps; ac_word=$2
6817 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6818 > $as_echo_n "checking for $ac_word... " >&6; }
6819 > if test "${ac_cv_path_PS+set}" = set; then :
6820 >  $as_echo_n "(cached) " >&6
6821 > else
6822 >  case $PS in
6823 >  [\\/]* | ?:[\\/]*)
6824 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
6825 >  ;;
6826 >  *)
6827 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6828 > for as_dir in $PATH
6829 > do
6830 >  IFS=$as_save_IFS
6831 >  test -z "$as_dir" && as_dir=.
6832 >    for ac_exec_ext in '' $ac_executable_extensions; do
6833 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6834 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
6835 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6836 >    break 2
6837 >  fi
6838 > done
6839 >  done
6840 > IFS=$as_save_IFS
6841 >
6842 >  ;;
6843 > esac
6844 > fi
6845 > PS=$ac_cv_path_PS
6846 > if test -n "$PS"; then
6847 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PS" >&5
6848 > $as_echo "$PS" >&6; }
6849 > else
6850 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6851 > $as_echo "no" >&6; }
6852 > fi
6853 >
6854 >
6855 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for POSIX or BSD ps syntax" >&5
6856 > $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
6857 > if test "${ac_cv_prog_ps_syntax+set}" = set; then :
6858 >  $as_echo_n "(cached) " >&6
6859 > else
6860 >
6861 >        if $PS ax -o rss > /dev/null 2>&1; then
6862 >                ac_cv_prog_ps_ax=yes
6863 >        else
6864 >                ac_cv_prog_ps_ax=no
6865 >        fi
6866 >        if $PS -ef -o rss > /dev/null 2>&1; then
6867 >                ac_cv_prog_ps_ef=yes
6868 >        else
6869 >                ac_cv_prog_ps_ef=no
6870 >        fi
6871 >        if test "$ac_cv_prog_ps_ax" = yes; then
6872 >                ac_cv_prog_ps_syntax=BSD
6873 >        else
6874 >                if test "$ac_cv_prog_ps_ef" = yes; then
6875 >                        ac_cv_prog_ps_syntax=POSIX
6876 >                else
6877 >                        as_fn_error "Could not determine ps syntax" "$LINENO" 5
6878 >                fi
6879 >        fi
6880 >
6881 > fi
6882 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_ps_syntax" >&5
6883 > $as_echo "$ac_cv_prog_ps_syntax" >&6; }
6884 >
6885 > cat >>confdefs.h <<_ACEOF
6886 > #define PSCOMMAND $PS
6887 > _ACEOF
6888 >
6889 > if test "$ac_cv_prog_ps_syntax" = BSD; then
6890 >
6891 > $as_echo "#define PSTYPE_IS_BSD 1" >>confdefs.h
6892 >
6893 > else
6894 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
6895 >
6896 > $as_echo "#define PSTYPE_IS_POSIX 1" >>confdefs.h
6897 >
6898 >   else
6899 >       as_fn_error "Unknown ps syntax type!" "$LINENO" 5
6900 >   fi
6901 > fi
6902 >
6903 > ac_ext=${ac_fc_srcext-f}
6904 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6905 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6906 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6907 >
6908 > ac_ext=${ac_fc_srcext-f}
6909 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6910 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6911 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6912 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran flag to compile .F90 files" >&5
6913 > $as_echo_n "checking for Fortran flag to compile .F90 files... " >&6; }
6914 > if test "${ac_cv_fc_srcext_F90+set}" = set; then :
6915 >  $as_echo_n "(cached) " >&6
6916 > else
6917 >  ac_ext=F90
6918 > ac_fcflags_srcext_save=$ac_fcflags_srcext
6919 > ac_fcflags_srcext=
6920 > ac_cv_fc_srcext_F90=unknown
6921 > for ac_flag in none -qsuffix=f=F90 -Tf; do
6922 >  test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
6923 >  cat > conftest.$ac_ext <<_ACEOF
6924 >      program main
6925 >
6926 >      end
6927 > _ACEOF
6928 > if ac_fn_fc_try_compile "$LINENO"; then :
6929 >  ac_cv_fc_srcext_F90=$ac_flag; break
6930 > fi
6931 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6932 > done
6933 > rm -f conftest.$ac_objext conftest.F90
6934 > ac_fcflags_srcext=$ac_fcflags_srcext_save
6935 >
6936 > fi
6937 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_srcext_F90" >&5
6938 > $as_echo "$ac_cv_fc_srcext_F90" >&6; }
6939 > if test "x$ac_cv_fc_srcext_F90" = xunknown; then
6940 >  as_fn_error "Fortran could not compile .F90 files" "$LINENO" 5
6941 > else
6942 >  ac_fc_srcext=F90
6943 >  if test "x$ac_cv_fc_srcext_F90" = xnone; then
6944 >    ac_fcflags_srcext=""
6945 >    FCFLAGS_F90=""
6946 >  else
6947 >    ac_fcflags_srcext=$ac_cv_fc_srcext_F90
6948 >    FCFLAGS_F90=$ac_cv_fc_srcext_F90
6949 >  fi
6950 >
6951 >
6952 > fi
6953 > ac_ext=${ac_fc_srcext-f}
6954 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6955 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6956 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6957 >
6958 >
6959 >
6960 >
6961 >
6962 > # Try to determine native compiler flags that allow us to use F90 suffix
6963 > # for preprocessed f90 source.
6964 >
6965 > if test "$ac_test_PREPFLAG" != "set"; then
6966 >  PREPFLAG=""
6967 >  case "${host_cpu}-${host_os}" in
6968 >
6969 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
6970 >                    PREPFLAG="-fpp1 "
6971 >                fi;;
6972 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
6973 >                    PREPFLAG="-qsuffix=cpp=F90 "
6974 >                fi;;
6975 >  *darwin*)
6976 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
6977 >                PREPFLAG="-qsuffix=cpp=F90 "
6978 >        fi;;
6979 >  esac
6980 >
6981 >  if test -z "$PREPFLAG"; then
6982 >        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Using empty PREPFLAG\"" >&5
6983 > $as_echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
6984 >        PREPFLAG=""
6985 >  fi
6986 >
6987 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking to make sure F90 preprocessor flag works" >&5
6988 > $as_echo_n "checking to make sure F90 preprocessor flag works... " >&6; }
6989 >
6990 >  ac_ext=${ac_fc_srcext-f}
6991 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6992 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6993 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6994 >
6995 >  ac_save_ext=$ac_ext
6996 >  ac_ext=F90
6997 >  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
6998 >
6999 >  if test "$PREPFLAG"; then :
7000 >  FCFLAGS_SRCEXT="${PREPFLAG}"
7001 > fi
7002 >    cat > conftest.$ac_ext <<_ACEOF
7003 >
7004 >
7005 > program conftest
7006 >  integer :: i
7007 >  i = 1
7008 > end program conftest
7009 >
7010 > _ACEOF
7011 > if ac_fn_fc_try_compile "$LINENO"; then :
7012 >  prepflagworks=1
7013 > else
7014 >  prepflagworks=0
7015 > fi
7016 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7017 >
7018 >  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
7019 >  ac_ext=$ac_save_ext
7020 >  ac_ext=${ac_fc_srcext-f}
7021 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7022 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7023 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7024 >
7025 >
7026 >  if test "$prepflagworks" = 1; then
7027 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
7028 > $as_echo "yes" >&6; }
7029 >    FCFLAGS_SRCEXT="${PREPFLAG}"
7030 >
7031 >  else
7032 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7033 > $as_echo "no" >&6; }
7034 >    as_fn_error "Can't figure out working Fortran90 preprocessor flag" "$LINENO" 5
7035 >  fi
7036 > fi
7037 >
7038 >
7039 >
7040 >
7041 >
7042 > # Try to determine native compiler flags that allow us to use F90 suffix
7043 > # for preprocessed f90 source with -D type defines
7044 >
7045 > if test "$ac_test_PREPDEFFLAG" != "set"; then
7046 >  PREPDEFFLAG=""
7047 >  case "${host_cpu}-${host_os}" in
7048 >
7049 >  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
7050 >                    PREPDEFFLAG=" "
7051 >                fi;;
7052 >  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
7053 >                    PREPDEFFLAG="-WF,"
7054 >                fi;;
7055 >  *darwin*)
7056 >        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
7057 >                PREPDEFFLAG="-WF,"
7058 >        fi;;
7059 >  esac
7060 >
7061 >  if test -z "$PREPDEFFLAG"; then
7062 >        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: \"Using empty PREPDEFFLAG\"" >&5
7063 > $as_echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
7064 >        PREPDEFFLAG=" "
7065 >  fi
7066 >
7067 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking to make sure F90 preprocessor define flag works" >&5
7068 > $as_echo_n "checking to make sure F90 preprocessor define flag works... " >&6; }
7069 >
7070 >  ac_ext=${ac_fc_srcext-f}
7071 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7072 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7073 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7074 >
7075 >  ac_save_ext=$ac_ext
7076 >  ac_ext=F90
7077 >  ac_save_FCFLAGS=$FCFLAGS
7078 >
7079 >  if test "$PREPDEFFLAG"; then :
7080 >  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
7081 > fi
7082 >    cat > conftest.$ac_ext <<_ACEOF
7083 >
7084 >
7085 > program conftest
7086 >  integer :: i
7087 > #ifdef TEST
7088 >  i = 1
7089 > #else
7090 >  choke me
7091 > #endif
7092 > end program conftest
7093 >
7094 > _ACEOF
7095 > if ac_fn_fc_try_compile "$LINENO"; then :
7096 >  prepdefflagworks=1
7097 > else
7098 >  prepdefflagworks=0
7099 > fi
7100 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7101 >
7102 >  FCFLAGS=$ac_save_FCFLAGS
7103 >  ac_ext=$ac_save_ext
7104 >  ac_ext=${ac_fc_srcext-f}
7105 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7106 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7107 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7108 >
7109 >
7110 >  if test "$prepdefflagworks" = 1; then
7111 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
7112 > $as_echo "yes" >&6; }
7113 >
7114 >  else
7115 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7116 > $as_echo "no" >&6; }
7117 >    as_fn_error "Can't figure out working Fortran90 preprocessor define flag" "$LINENO" 5
7118 >  fi
7119 > fi
7120 >
7121 > ac_ext=${ac_fc_srcext-f}
7122 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7123 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7124 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7125 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to get verbose linking output from $FC" >&5
7126 > $as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
7127 > if test "${ac_cv_prog_fc_v+set}" = set; then :
7128 >  $as_echo_n "(cached) " >&6
7129 > else
7130 >  cat > conftest.$ac_ext <<_ACEOF
7131 >      program main
7132 >
7133 >      end
7134 > _ACEOF
7135 > if ac_fn_fc_try_compile "$LINENO"; then :
7136 >  ac_cv_prog_fc_v=
7137 > # Try some options frequently used verbose output
7138 > for ac_verb in -v -verbose --verbose -V -\#\#\#; do
7139 >  cat > conftest.$ac_ext <<_ACEOF
7140 >      program main
7141 >
7142 >      end
7143 > _ACEOF
7144 >
7145 > # Compile and link our simple test program by passing a flag (argument
7146 > # 1 to this macro) to the Fortran compiler in order to get
7147 > # "verbose" output that we can then parse for the Fortran linker
7148 > # flags.
7149 > ac_save_FCFLAGS=$FCFLAGS
7150 > FCFLAGS="$FCFLAGS $ac_verb"
7151 > eval "set x $ac_link"
7152 > shift
7153 > $as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7154 > # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7155 > # LIBRARY_PATH; skip all such settings.
7156 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
7157 >  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7158 > $as_echo "$ac_fc_v_output" >&5
7159 > FCFLAGS=$ac_save_FCFLAGS
7160 >
7161 > rm -rf conftest*
7162 >
7163 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
7164 > # /foo, /bar, and /baz are search directories for the Fortran linker.
7165 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
7166 > ac_fc_v_output="`echo $ac_fc_v_output |
7167 >        grep 'LPATH is:' |
7168 >        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
7169 >
7170 > # FIXME: we keep getting bitten by quoted arguments; a more general fix
7171 > #        that detects unbalanced quotes in FLIBS should be implemented
7172 > #        and (ugh) tested at some point.
7173 > case $ac_fc_v_output in
7174 >  # If we are using xlf then replace all the commas with spaces.
7175 >  *xlfentry*)
7176 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
7177 >
7178 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
7179 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
7180 >  *mGLOB_options_string*)
7181 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
7182 >
7183 >  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
7184 >  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
7185 >  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7186 >  *-cmdline\ * | *-ignore\ * | *-def\ *)
7187 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
7188 >        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
7189 >        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
7190 >        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
7191 >
7192 >  # If we are using Cray Fortran then delete quotes.
7193 >  *cft90*)
7194 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
7195 > esac
7196 >
7197 >
7198 >  # look for -l* and *.a constructs in the output
7199 >  for ac_arg in $ac_fc_v_output; do
7200 >     case $ac_arg in
7201 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
7202 >          ac_cv_prog_fc_v=$ac_verb
7203 >          break 2 ;;
7204 >     esac
7205 >  done
7206 > done
7207 > if test -z "$ac_cv_prog_fc_v"; then
7208 >   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot determine how to obtain linking information from $FC" >&5
7209 > $as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
7210 > fi
7211 > else
7212 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: compilation failed" >&5
7213 > $as_echo "$as_me: WARNING: compilation failed" >&2;}
7214 > fi
7215 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7216 >
7217 > fi
7218 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_v" >&5
7219 > $as_echo "$ac_cv_prog_fc_v" >&6; }
7220 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran libraries of $FC" >&5
7221 > $as_echo_n "checking for Fortran libraries of $FC... " >&6; }
7222 > if test "${ac_cv_fc_libs+set}" = set; then :
7223 >  $as_echo_n "(cached) " >&6
7224 > else
7225 >  if test "x$FCLIBS" != "x"; then
7226 >  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
7227 > else
7228 >
7229 > cat > conftest.$ac_ext <<_ACEOF
7230 >      program main
7231 >
7232 >      end
7233 > _ACEOF
7234 >
7235 > # Compile and link our simple test program by passing a flag (argument
7236 > # 1 to this macro) to the Fortran compiler in order to get
7237 > # "verbose" output that we can then parse for the Fortran linker
7238 > # flags.
7239 > ac_save_FCFLAGS=$FCFLAGS
7240 > FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
7241 > eval "set x $ac_link"
7242 > shift
7243 > $as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7244 > # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7245 > # LIBRARY_PATH; skip all such settings.
7246 > ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
7247 >  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7248 > $as_echo "$ac_fc_v_output" >&5
7249 > FCFLAGS=$ac_save_FCFLAGS
7250 >
7251 > rm -rf conftest*
7252 >
7253 > # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
7254 > # /foo, /bar, and /baz are search directories for the Fortran linker.
7255 > # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
7256 > ac_fc_v_output="`echo $ac_fc_v_output |
7257 >        grep 'LPATH is:' |
7258 >        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
7259 >
7260 > # FIXME: we keep getting bitten by quoted arguments; a more general fix
7261 > #        that detects unbalanced quotes in FLIBS should be implemented
7262 > #        and (ugh) tested at some point.
7263 > case $ac_fc_v_output in
7264 >  # If we are using xlf then replace all the commas with spaces.
7265 >  *xlfentry*)
7266 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
7267 >
7268 >  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
7269 >  # $LIBS confuse us, and the libraries appear later in the output anyway).
7270 >  *mGLOB_options_string*)
7271 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
7272 >
7273 >  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
7274 >  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
7275 >  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7276 >  *-cmdline\ * | *-ignore\ * | *-def\ *)
7277 >    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
7278 >        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
7279 >        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
7280 >        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
7281 >
7282 >  # If we are using Cray Fortran then delete quotes.
7283 >  *cft90*)
7284 >    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
7285 > esac
7286 >
7287 >
7288 >
7289 > ac_cv_fc_libs=
7290 >
7291 > # Save positional arguments (if any)
7292 > ac_save_positional="$@"
7293 >
7294 > set X $ac_fc_v_output
7295 > while test $# != 1; do
7296 >  shift
7297 >  ac_arg=$1
7298 >  case $ac_arg in
7299 >        [\\/]*.a | ?:[\\/]*.a)
7300 >            ac_exists=false
7301 >  for ac_i in $ac_cv_fc_libs; do
7302 >    if test x"$ac_arg" = x"$ac_i"; then
7303 >      ac_exists=true
7304 >      break
7305 >    fi
7306 >  done
7307 >
7308 >  if test x"$ac_exists" = xtrue; then :
7309 >
7310 > else
7311 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7312 > fi
7313 >          ;;
7314 >        -bI:*)
7315 >            ac_exists=false
7316 >  for ac_i in $ac_cv_fc_libs; do
7317 >    if test x"$ac_arg" = x"$ac_i"; then
7318 >      ac_exists=true
7319 >      break
7320 >    fi
7321 >  done
7322 >
7323 >  if test x"$ac_exists" = xtrue; then :
7324 >
7325 > else
7326 >  if test "$ac_compiler_gnu" = yes; then
7327 >  for ac_link_opt in $ac_arg; do
7328 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
7329 >  done
7330 > else
7331 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7332 > fi
7333 > fi
7334 >          ;;
7335 >          # Ignore these flags.
7336 >        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -little \
7337 >          |-LANG:=* | -LIST:* | -LNO:*)
7338 >          ;;
7339 >        -lkernel32)
7340 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7341 >          ;;
7342 >        -[LRuYz])
7343 >          # These flags, when seen by themselves, take an argument.
7344 >          # We remove the space between option and argument and re-iterate
7345 >          # unless we find an empty arg or a new option (starting with -)
7346 >          case $2 in
7347 >             "" | -*);;
7348 >             *)
7349 >                ac_arg="$ac_arg$2"
7350 >                shift; shift
7351 >                set X $ac_arg "$@"
7352 >                ;;
7353 >          esac
7354 >          ;;
7355 >        -YP,*)
7356 >          for ac_j in `$as_echo "$ac_arg" | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7357 >              ac_exists=false
7358 >  for ac_i in $ac_cv_fc_libs; do
7359 >    if test x"$ac_j" = x"$ac_i"; then
7360 >      ac_exists=true
7361 >      break
7362 >    fi
7363 >  done
7364 >
7365 >  if test x"$ac_exists" = xtrue; then :
7366 >
7367 > else
7368 >  ac_arg="$ac_arg $ac_j"
7369 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
7370 > fi
7371 >          done
7372 >          ;;
7373 >        -[lLR]*)
7374 >            ac_exists=false
7375 >  for ac_i in $ac_cv_fc_libs; do
7376 >    if test x"$ac_arg" = x"$ac_i"; then
7377 >      ac_exists=true
7378 >      break
7379 >    fi
7380 >  done
7381 >
7382 >  if test x"$ac_exists" = xtrue; then :
7383 >
7384 > else
7385 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7386 > fi
7387 >          ;;
7388 >        -zallextract*| -zdefaultextract)
7389 >          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7390 >          ;;
7391 >          # Ignore everything else.
7392 >  esac
7393 > done
7394 > # restore positional arguments
7395 > set X $ac_save_positional; shift
7396 >
7397 > # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
7398 > # then we insist that the "run path" must be an absolute path (i.e. it
7399 > # must begin with a "/").
7400 > case `(uname -sr) 2>/dev/null` in
7401 >   "SunOS 5"*)
7402 >      ac_ld_run_path=`$as_echo "$ac_fc_v_output" |
7403 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
7404 >      test "x$ac_ld_run_path" != x &&
7405 >        if test "$ac_compiler_gnu" = yes; then
7406 >  for ac_link_opt in $ac_ld_run_path; do
7407 >    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
7408 >  done
7409 > else
7410 >  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
7411 > fi
7412 >      ;;
7413 > esac
7414 > fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
7415 >
7416 > fi
7417 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_libs" >&5
7418 > $as_echo "$ac_cv_fc_libs" >&6; }
7419 > FCLIBS="$ac_cv_fc_libs"
7420 >
7421 >
7422 > ac_ext=${ac_fc_srcext-f}
7423 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7424 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7425 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7426 >
7427 > ac_ext=${ac_fc_srcext-f}
7428 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7429 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7430 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7431 >
7432 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dummy main to link with Fortran libraries" >&5
7433 > $as_echo_n "checking for dummy main to link with Fortran libraries... " >&6; }
7434 > if test "${ac_cv_fc_dummy_main+set}" = set; then :
7435 >  $as_echo_n "(cached) " >&6
7436 > else
7437 >  ac_fc_dm_save_LIBS=$LIBS
7438 > LIBS="$LIBS $FCLIBS"
7439 > ac_fortran_dm_var=FC_DUMMY_MAIN
7440 > ac_ext=c
7441 > ac_cpp='$CPP $CPPFLAGS'
7442 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7443 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7444 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
7445 >
7446 > # First, try linking without a dummy main:
7447 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7448 > /* end confdefs.h.  */
7449 >
7450 > #ifdef FC_DUMMY_MAIN
7451 > #ifndef FC_DUMMY_MAIN_EQ_F77
7452 > #  ifdef __cplusplus
7453 >     extern "C"
7454 > #  endif
7455 >   int FC_DUMMY_MAIN() { return 1; }
7456 > #endif
7457 > #endif
7458 > int
7459 > main ()
7460 > {
7461 >
7462 >  ;
7463 >  return 0;
7464 > }
7465 > _ACEOF
7466 > if ac_fn_c_try_link "$LINENO"; then :
7467 >  ac_cv_fortran_dummy_main=none
7468 > else
7469 >  ac_cv_fortran_dummy_main=unknown
7470 > fi
7471 > rm -f core conftest.err conftest.$ac_objext \
7472 >    conftest$ac_exeext conftest.$ac_ext
7473 >
7474 > if test $ac_cv_fortran_dummy_main = unknown; then
7475 >   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
7476 >     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7477 > /* end confdefs.h.  */
7478 > #define $ac_fortran_dm_var $ac_func
7479 > #ifdef FC_DUMMY_MAIN
7480 > #ifndef FC_DUMMY_MAIN_EQ_F77
7481 > #  ifdef __cplusplus
7482 >     extern "C"
7483 > #  endif
7484 >   int FC_DUMMY_MAIN() { return 1; }
7485 > #endif
7486 > #endif
7487 > int
7488 > main ()
7489 > {
7490 >
7491 >  ;
7492 >  return 0;
7493 > }
7494 > _ACEOF
7495 > if ac_fn_c_try_link "$LINENO"; then :
7496 >  ac_cv_fortran_dummy_main=$ac_func; break
7497 > fi
7498 > rm -f core conftest.err conftest.$ac_objext \
7499 >    conftest$ac_exeext conftest.$ac_ext
7500 >   done
7501 > fi
7502 > ac_ext=${ac_fc_srcext-f}
7503 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7504 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7505 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7506 > ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
7507 > rm -rf conftest*
7508 > LIBS=$ac_fc_dm_save_LIBS
7509 >
7510 > fi
7511 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_dummy_main" >&5
7512 > $as_echo "$ac_cv_fc_dummy_main" >&6; }
7513 > FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
7514 > if test "$FC_DUMMY_MAIN" != unknown; then :
7515 >  if test $FC_DUMMY_MAIN != none; then
7516 >
7517 > cat >>confdefs.h <<_ACEOF
7518 > #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
7519 > _ACEOF
7520 >
7521 >  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
7522 >
7523 > $as_echo "#define FC_DUMMY_MAIN_EQ_F77 1" >>confdefs.h
7524 >
7525 >  fi
7526 > fi
7527 > else
7528 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
7529 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
7530 > as_fn_error "linking to Fortran libraries from C fails
7531 > See \`config.log' for more details." "$LINENO" 5; }
7532 > fi
7533 >
7534 > ac_ext=${ac_fc_srcext-f}
7535 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7536 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7537 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7538 >
7539 > ac_ext=${ac_fc_srcext-f}
7540 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7541 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7542 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7543 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran name-mangling scheme" >&5
7544 > $as_echo_n "checking for Fortran name-mangling scheme... " >&6; }
7545 > if test "${ac_cv_fc_mangling+set}" = set; then :
7546 >  $as_echo_n "(cached) " >&6
7547 > else
7548 >  cat > conftest.$ac_ext <<_ACEOF
7549 >      subroutine foobar()
7550 >      return
7551 >      end
7552 >      subroutine foo_bar()
7553 >      return
7554 >      end
7555 > _ACEOF
7556 > if ac_fn_fc_try_compile "$LINENO"; then :
7557 >  mv conftest.$ac_objext cfortran_test.$ac_objext
7558 >
7559 >  ac_save_LIBS=$LIBS
7560 >  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
7561 >
7562 >  ac_ext=c
7563 > ac_cpp='$CPP $CPPFLAGS'
7564 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7565 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7566 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
7567 >  ac_success=no
7568 >  for ac_foobar in foobar FOOBAR; do
7569 >    for ac_underscore in "" "_"; do
7570 >      ac_func="$ac_foobar$ac_underscore"
7571 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7572 > /* end confdefs.h.  */
7573 >
7574 > /* Override any GCC internal prototype to avoid an error.
7575 >   Use char because int might match the return type of a GCC
7576 >   builtin and then its argument prototype would still apply.  */
7577 > #ifdef __cplusplus
7578 > extern "C"
7579 > #endif
7580 > char $ac_func ();
7581 > #ifdef FC_DUMMY_MAIN
7582 > #ifndef FC_DUMMY_MAIN_EQ_F77
7583 > #  ifdef __cplusplus
7584 >     extern "C"
7585 > #  endif
7586 >   int FC_DUMMY_MAIN() { return 1; }
7587 > #endif
7588 > #endif
7589 > int
7590 > main ()
7591 > {
7592 > return $ac_func ();
7593 >  ;
7594 >  return 0;
7595 > }
7596 > _ACEOF
7597 > if ac_fn_c_try_link "$LINENO"; then :
7598 >  ac_success=yes; break 2
7599 > fi
7600 > rm -f core conftest.err conftest.$ac_objext \
7601 >    conftest$ac_exeext conftest.$ac_ext
7602 >    done
7603 >  done
7604 >  ac_ext=${ac_fc_srcext-f}
7605 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7606 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7607 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7608 >
7609 >  if test "$ac_success" = "yes"; then
7610 >     case $ac_foobar in
7611 >        foobar)
7612 >           ac_case=lower
7613 >           ac_foo_bar=foo_bar
7614 >           ;;
7615 >        FOOBAR)
7616 >           ac_case=upper
7617 >           ac_foo_bar=FOO_BAR
7618 >           ;;
7619 >     esac
7620 >
7621 >     ac_ext=c
7622 > ac_cpp='$CPP $CPPFLAGS'
7623 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7624 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7625 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
7626 >     ac_success_extra=no
7627 >     for ac_extra in "" "_"; do
7628 >        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
7629 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
7630 > /* end confdefs.h.  */
7631 >
7632 > /* Override any GCC internal prototype to avoid an error.
7633 >   Use char because int might match the return type of a GCC
7634 >   builtin and then its argument prototype would still apply.  */
7635 > #ifdef __cplusplus
7636 > extern "C"
7637 > #endif
7638 > char $ac_func ();
7639 > #ifdef FC_DUMMY_MAIN
7640 > #ifndef FC_DUMMY_MAIN_EQ_F77
7641 > #  ifdef __cplusplus
7642 >     extern "C"
7643 > #  endif
7644 >   int FC_DUMMY_MAIN() { return 1; }
7645 > #endif
7646 > #endif
7647 > int
7648 > main ()
7649 > {
7650 > return $ac_func ();
7651 >  ;
7652 >  return 0;
7653 > }
7654 > _ACEOF
7655 > if ac_fn_c_try_link "$LINENO"; then :
7656 >  ac_success_extra=yes; break
7657 > fi
7658 > rm -f core conftest.err conftest.$ac_objext \
7659 >    conftest$ac_exeext conftest.$ac_ext
7660 >     done
7661 >     ac_ext=${ac_fc_srcext-f}
7662 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7663 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7664 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7665 >
7666 >     if test "$ac_success_extra" = "yes"; then
7667 >        ac_cv_fc_mangling="$ac_case case"
7668 >        if test -z "$ac_underscore"; then
7669 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
7670 >        else
7671 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
7672 >        fi
7673 >        if test -z "$ac_extra"; then
7674 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
7675 >        else
7676 >           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
7677 >        fi
7678        else
7679          ac_cv_fc_mangling="unknown"
7680        fi
# Line 6697 | Line 7686 | else
7686    rm -rf conftest*
7687    rm -f cfortran_test*
7688   else
7689 <  $as_echo "$as_me: failed program was:" >&5
7690 < sed 's/^/| /' conftest.$ac_ext >&5
7691 <
7692 <        { { $as_echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
6704 < See \`config.log' for more details." >&5
6705 < $as_echo "$as_me: error: cannot compile a simple Fortran program
6706 < See \`config.log' for more details." >&2;}
6707 <   { (exit 1); exit 1; }; }
7689 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
7690 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
7691 > as_fn_error "cannot compile a simple Fortran program
7692 > See \`config.log' for more details." "$LINENO" 5; }
7693   fi
6709 –
7694   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7695  
7696   fi
7697 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
7697 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_mangling" >&5
7698   $as_echo "$ac_cv_fc_mangling" >&6; }
7699  
7700   ac_ext=${ac_fc_srcext-f}
# Line 6722 | Line 7706 | ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7706   ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7707   ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7708   ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6725 –
6726 –
7709   case $ac_cv_fc_mangling in
7710    "lower case, no underscore, no extra underscore")
7711 <          cat >>confdefs.h <<\_ACEOF
6730 < #define FC_FUNC(name,NAME) name
6731 < _ACEOF
7711 >          $as_echo "#define FC_FUNC(name,NAME) name" >>confdefs.h
7712  
7713 <          cat >>confdefs.h <<\_ACEOF
6734 < #define FC_FUNC_(name,NAME) name
6735 < _ACEOF
7713 >          $as_echo "#define FC_FUNC_(name,NAME) name" >>confdefs.h
7714   ;;
7715    "lower case, no underscore, extra underscore")
7716 <          cat >>confdefs.h <<\_ACEOF
6739 < #define FC_FUNC(name,NAME) name
6740 < _ACEOF
7716 >          $as_echo "#define FC_FUNC(name,NAME) name" >>confdefs.h
7717  
7718 <          cat >>confdefs.h <<\_ACEOF
6743 < #define FC_FUNC_(name,NAME) name ## _
6744 < _ACEOF
7718 >          $as_echo "#define FC_FUNC_(name,NAME) name ## _" >>confdefs.h
7719   ;;
7720    "lower case, underscore, no extra underscore")
7721 <          cat >>confdefs.h <<\_ACEOF
6748 < #define FC_FUNC(name,NAME) name ## _
6749 < _ACEOF
7721 >          $as_echo "#define FC_FUNC(name,NAME) name ## _" >>confdefs.h
7722  
7723 <          cat >>confdefs.h <<\_ACEOF
6752 < #define FC_FUNC_(name,NAME) name ## _
6753 < _ACEOF
7723 >          $as_echo "#define FC_FUNC_(name,NAME) name ## _" >>confdefs.h
7724   ;;
7725    "lower case, underscore, extra underscore")
7726 <          cat >>confdefs.h <<\_ACEOF
6757 < #define FC_FUNC(name,NAME) name ## _
6758 < _ACEOF
7726 >          $as_echo "#define FC_FUNC(name,NAME) name ## _" >>confdefs.h
7727  
7728 <          cat >>confdefs.h <<\_ACEOF
6761 < #define FC_FUNC_(name,NAME) name ## __
6762 < _ACEOF
7728 >          $as_echo "#define FC_FUNC_(name,NAME) name ## __" >>confdefs.h
7729   ;;
7730    "upper case, no underscore, no extra underscore")
7731 <          cat >>confdefs.h <<\_ACEOF
6766 < #define FC_FUNC(name,NAME) NAME
6767 < _ACEOF
7731 >          $as_echo "#define FC_FUNC(name,NAME) NAME" >>confdefs.h
7732  
7733 <          cat >>confdefs.h <<\_ACEOF
6770 < #define FC_FUNC_(name,NAME) NAME
6771 < _ACEOF
7733 >          $as_echo "#define FC_FUNC_(name,NAME) NAME" >>confdefs.h
7734   ;;
7735    "upper case, no underscore, extra underscore")
7736 <          cat >>confdefs.h <<\_ACEOF
6775 < #define FC_FUNC(name,NAME) NAME
6776 < _ACEOF
7736 >          $as_echo "#define FC_FUNC(name,NAME) NAME" >>confdefs.h
7737  
7738 <          cat >>confdefs.h <<\_ACEOF
6779 < #define FC_FUNC_(name,NAME) NAME ## _
6780 < _ACEOF
7738 >          $as_echo "#define FC_FUNC_(name,NAME) NAME ## _" >>confdefs.h
7739   ;;
7740    "upper case, underscore, no extra underscore")
7741 <          cat >>confdefs.h <<\_ACEOF
6784 < #define FC_FUNC(name,NAME) NAME ## _
6785 < _ACEOF
7741 >          $as_echo "#define FC_FUNC(name,NAME) NAME ## _" >>confdefs.h
7742  
7743 <          cat >>confdefs.h <<\_ACEOF
6788 < #define FC_FUNC_(name,NAME) NAME ## _
6789 < _ACEOF
7743 >          $as_echo "#define FC_FUNC_(name,NAME) NAME ## _" >>confdefs.h
7744   ;;
7745    "upper case, underscore, extra underscore")
7746 <          cat >>confdefs.h <<\_ACEOF
6793 < #define FC_FUNC(name,NAME) NAME ## _
6794 < _ACEOF
7746 >          $as_echo "#define FC_FUNC(name,NAME) NAME ## _" >>confdefs.h
7747  
7748 <          cat >>confdefs.h <<\_ACEOF
6797 < #define FC_FUNC_(name,NAME) NAME ## __
6798 < _ACEOF
7748 >          $as_echo "#define FC_FUNC_(name,NAME) NAME ## __" >>confdefs.h
7749   ;;
7750    *)
7751 <          { $as_echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
7751 >          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unknown Fortran name-mangling scheme" >&5
7752   $as_echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
7753 <          ;;
7753 >          ;;
7754   esac
7755  
7756   ac_ext=${ac_fc_srcext-f}
# Line 6814 | Line 7764 | ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7764   ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7765   ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7766   ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7767 < { $as_echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
7767 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to get verbose linking output from $FC" >&5
7768   $as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
7769 < if test "${ac_cv_prog_fc_v+set}" = set; then
7769 > if test "${ac_cv_prog_fc_v+set}" = set; then :
7770    $as_echo_n "(cached) " >&6
7771   else
7772 <  cat >conftest.$ac_ext <<_ACEOF
7772 >  cat > conftest.$ac_ext <<_ACEOF
7773        program main
7774  
7775        end
7776   _ACEOF
7777 < rm -f conftest.$ac_objext
6828 < if { (ac_try="$ac_compile"
6829 < case "(($ac_try" in
6830 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6831 <  *) ac_try_echo=$ac_try;;
6832 < esac
6833 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6834 < $as_echo "$ac_try_echo") >&5
6835 <  (eval "$ac_compile") 2>conftest.er1
6836 <  ac_status=$?
6837 <  grep -v '^ *+' conftest.er1 >conftest.err
6838 <  rm -f conftest.er1
6839 <  cat conftest.err >&5
6840 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6841 <  (exit $ac_status); } && {
6842 <         test -z "$ac_fc_werror_flag" ||
6843 <         test ! -s conftest.err
6844 <       } && test -s conftest.$ac_objext; then
7777 > if ac_fn_fc_try_compile "$LINENO"; then :
7778    ac_cv_prog_fc_v=
7779   # Try some options frequently used verbose output
7780   for ac_verb in -v -verbose --verbose -V -\#\#\#; do
7781 <  cat >conftest.$ac_ext <<_ACEOF
7781 >  cat > conftest.$ac_ext <<_ACEOF
7782        program main
7783  
7784        end
# Line 6855 | Line 7788 | _ACEOF
7788   # 1 to this macro) to the Fortran compiler in order to get
7789   # "verbose" output that we can then parse for the Fortran linker
7790   # flags.
7791 < ac_save_FFLAGS=$FCFLAGS
7791 > ac_save_FCFLAGS=$FCFLAGS
7792   FCFLAGS="$FCFLAGS $ac_verb"
7793   eval "set x $ac_link"
7794   shift
7795 < $as_echo "$as_me:$LINENO: $*" >&5
7795 > $as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7796   # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7797   # LIBRARY_PATH; skip all such settings.
7798   ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
7799    grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7800   $as_echo "$ac_fc_v_output" >&5
7801 < FCFLAGS=$ac_save_FFLAGS
7801 > FCFLAGS=$ac_save_FCFLAGS
7802  
7803   rm -rf conftest*
7804  
# Line 6894 | Line 7827 | case $ac_fc_v_output in
7827    # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7828    *-cmdline\ * | *-ignore\ * | *-def\ *)
7829      ac_fc_v_output=`echo $ac_fc_v_output | sed "\
7830 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
7831 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
7832 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
7830 >        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
7831 >        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
7832 >        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
7833  
7834    # If we are using Cray Fortran then delete quotes.
7835    *cft90*)
# Line 6907 | Line 7840 | esac
7840    # look for -l* and *.a constructs in the output
7841    for ac_arg in $ac_fc_v_output; do
7842       case $ac_arg in
7843 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
7844 <          ac_cv_prog_fc_v=$ac_verb
7845 <          break 2 ;;
7843 >        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
7844 >          ac_cv_prog_fc_v=$ac_verb
7845 >          break 2 ;;
7846       esac
7847    done
7848   done
7849   if test -z "$ac_cv_prog_fc_v"; then
7850 <   { $as_echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
7850 >   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot determine how to obtain linking information from $FC" >&5
7851   $as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
7852   fi
7853   else
7854 <  $as_echo "$as_me: failed program was:" >&5
6922 < sed 's/^/| /' conftest.$ac_ext >&5
6923 <
6924 <        { $as_echo "$as_me:$LINENO: WARNING: compilation failed" >&5
7854 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: compilation failed" >&5
7855   $as_echo "$as_me: WARNING: compilation failed" >&2;}
7856   fi
6927 –
7857   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7858  
7859   fi
7860 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
7860 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_fc_v" >&5
7861   $as_echo "$ac_cv_prog_fc_v" >&6; }
7862 < { $as_echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
7862 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran libraries of $FC" >&5
7863   $as_echo_n "checking for Fortran libraries of $FC... " >&6; }
7864 < if test "${ac_cv_fc_libs+set}" = set; then
7864 > if test "${ac_cv_fc_libs+set}" = set; then :
7865    $as_echo_n "(cached) " >&6
7866   else
7867    if test "x$FCLIBS" != "x"; then
7868    ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
7869   else
7870  
7871 < cat >conftest.$ac_ext <<_ACEOF
7871 > cat > conftest.$ac_ext <<_ACEOF
7872        program main
7873  
7874        end
# Line 6949 | Line 7878 | _ACEOF
7878   # 1 to this macro) to the Fortran compiler in order to get
7879   # "verbose" output that we can then parse for the Fortran linker
7880   # flags.
7881 < ac_save_FFLAGS=$FCFLAGS
7881 > ac_save_FCFLAGS=$FCFLAGS
7882   FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
7883   eval "set x $ac_link"
7884   shift
7885 < $as_echo "$as_me:$LINENO: $*" >&5
7885 > $as_echo "$as_me:${as_lineno-$LINENO}: $*" >&5
7886   # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
7887   # LIBRARY_PATH; skip all such settings.
7888   ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
7889    grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
7890   $as_echo "$ac_fc_v_output" >&5
7891 < FCFLAGS=$ac_save_FFLAGS
7891 > FCFLAGS=$ac_save_FCFLAGS
7892  
7893   rm -rf conftest*
7894  
# Line 6988 | Line 7917 | case $ac_fc_v_output in
7917    # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
7918    *-cmdline\ * | *-ignore\ * | *-def\ *)
7919      ac_fc_v_output=`echo $ac_fc_v_output | sed "\
7920 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
7921 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
7922 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
7920 >        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
7921 >        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
7922 >        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
7923  
7924    # If we are using Cray Fortran then delete quotes.
7925    *cft90*)
# Line 7009 | Line 7938 | while test $# != 1; do
7938    shift
7939    ac_arg=$1
7940    case $ac_arg in
7941 <        [\\/]*.a | ?:[\\/]*.a)
7942 <            ac_exists=false
7941 >        [\\/]*.a | ?:[\\/]*.a)
7942 >            ac_exists=false
7943    for ac_i in $ac_cv_fc_libs; do
7944      if test x"$ac_arg" = x"$ac_i"; then
7945        ac_exists=true
# Line 7018 | Line 7947 | while test $# != 1; do
7947      fi
7948    done
7949  
7950 <  if test x"$ac_exists" = xtrue; then
7951 <  :
7950 >  if test x"$ac_exists" = xtrue; then :
7951 >
7952   else
7953    ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7954   fi
7955 <
7956 <          ;;
7957 <        -bI:*)
7029 <            ac_exists=false
7955 >          ;;
7956 >        -bI:*)
7957 >            ac_exists=false
7958    for ac_i in $ac_cv_fc_libs; do
7959      if test x"$ac_arg" = x"$ac_i"; then
7960        ac_exists=true
# Line 7034 | Line 7962 | fi
7962      fi
7963    done
7964  
7965 <  if test x"$ac_exists" = xtrue; then
7966 <  :
7965 >  if test x"$ac_exists" = xtrue; then :
7966 >
7967   else
7968    if test "$ac_compiler_gnu" = yes; then
7969    for ac_link_opt in $ac_arg; do
# Line 7045 | Line 7973 | fi
7973    ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7974   fi
7975   fi
7976 <
7977 <          ;;
7978 <          # Ignore these flags.
7979 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
7980 <          ;;
7981 <        -lkernel32)
7982 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7983 <          ;;
7984 <        -[LRuYz])
7985 <          # These flags, when seen by themselves, take an argument.
7986 <          # We remove the space between option and argument and re-iterate
7987 <          # unless we find an empty arg or a new option (starting with -)
7976 >          ;;
7977 >          # Ignore these flags.
7978 >        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -little \
7979 >          |-LANG:=* | -LIST:* | -LNO:*)
7980 >          ;;
7981 >        -lkernel32)
7982 >          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7983 >          ;;
7984 >        -[LRuYz])
7985 >          # These flags, when seen by themselves, take an argument.
7986 >          # We remove the space between option and argument and re-iterate
7987 >          # unless we find an empty arg or a new option (starting with -)
7988            case $2 in
7989               "" | -*);;
7990               *)
# Line 7065 | Line 7993 | fi
7993                  set X $ac_arg "$@"
7994                  ;;
7995            esac
7996 <          ;;
7997 <        -YP,*)
7998 <          for ac_j in `$as_echo "$ac_arg" | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7999 <              ac_exists=false
7996 >          ;;
7997 >        -YP,*)
7998 >          for ac_j in `$as_echo "$ac_arg" | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7999 >              ac_exists=false
8000    for ac_i in $ac_cv_fc_libs; do
8001      if test x"$ac_j" = x"$ac_i"; then
8002        ac_exists=true
# Line 7076 | Line 8004 | fi
8004      fi
8005    done
8006  
8007 <  if test x"$ac_exists" = xtrue; then
8008 <  :
8007 >  if test x"$ac_exists" = xtrue; then :
8008 >
8009   else
8010    ac_arg="$ac_arg $ac_j"
8011 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
8011 >                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
8012   fi
8013 <
8014 <          done
8015 <          ;;
8016 <        -[lLR]*)
7089 <            ac_exists=false
8013 >          done
8014 >          ;;
8015 >        -[lLR]*)
8016 >            ac_exists=false
8017    for ac_i in $ac_cv_fc_libs; do
8018      if test x"$ac_arg" = x"$ac_i"; then
8019        ac_exists=true
# Line 7094 | Line 8021 | fi
8021      fi
8022    done
8023  
8024 <  if test x"$ac_exists" = xtrue; then
8025 <  :
8024 >  if test x"$ac_exists" = xtrue; then :
8025 >
8026   else
8027    ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
8028   fi
8029 <
7103 <          ;;
8029 >          ;;
8030          -zallextract*| -zdefaultextract)
8031            ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
8032            ;;
8033 <          # Ignore everything else.
8033 >          # Ignore everything else.
8034    esac
8035   done
8036   # restore positional arguments
# Line 7116 | Line 8042 | case `(uname -sr) 2>/dev/null` in
8042   case `(uname -sr) 2>/dev/null` in
8043     "SunOS 5"*)
8044        ac_ld_run_path=`$as_echo "$ac_fc_v_output" |
8045 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
8045 >                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
8046        test "x$ac_ld_run_path" != x &&
8047 <        if test "$ac_compiler_gnu" = yes; then
8047 >        if test "$ac_compiler_gnu" = yes; then
8048    for ac_link_opt in $ac_ld_run_path; do
8049      ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
8050    done
# Line 7130 | Line 8056 | fi
8056   fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
8057  
8058   fi
8059 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
8059 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_fc_libs" >&5
8060   $as_echo "$ac_cv_fc_libs" >&6; }
8061   FCLIBS="$ac_cv_fc_libs"
8062  
# Line 7142 | Line 8068 | ac_compiler_gnu=$ac_cv_fc_compiler_gnu
8068  
8069  
8070  
8071 < { $as_echo "$as_me:$LINENO: checking for module suffix" >&5
8071 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for module suffix" >&5
8072   $as_echo_n "checking for module suffix... " >&6; }
8073   rm -f conftest*
8074   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
# Line 7169 | Line 8095 | if (eval $ac_compile) 2>/dev/null ; then
8095          fi
8096      fi
8097      if test -z "$MOD" ; then
8098 <        { $as_echo "$as_me:$LINENO: result: unknown" >&5
8098 >        { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
8099   $as_echo "unknown" >&6; }
8100          # Use mod if we can't figure it out
8101          MOD="mod"
8102      else
8103 <        { $as_echo "$as_me:$LINENO: result: $MOD" >&5
8103 >        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MOD" >&5
8104   $as_echo "$MOD" >&6; }
8105      fi
8106      if test -s work.pcl ; then
8107 <        { $as_echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
8107 >        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Compiler generates auxillery files!" >&5
8108   $as_echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
8109      fi
8110   else
8111 <    { $as_echo "$as_me:$LINENO: result: unknown" >&5
8111 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
8112   $as_echo "unknown" >&6; }
8113   fi
8114  
# Line 7196 | Line 8122 | fi
8122   # specified, work.pcl and work.pc are created.  However, if you specify
8123   # a file, it must contain a the name of a file ending in .pc .  Ugh!
8124   # Use the module made above
8125 < { $as_echo "$as_me:$LINENO: checking for module directory path flag" >&5
8125 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for module directory path flag" >&5
8126   $as_echo_n "checking for module directory path flag... " >&6; }
8127   rm -f conftest*
8128   # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
# Line 7230 | Line 8156 | EOF
8156     if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
8157         MODDIRFLAG="-I"
8158         F90MODINCSPEC="-I<dir>"
8159 <       { $as_echo "$as_me:$LINENO: result: -I" >&5
8159 >       { $as_echo "$as_me:${as_lineno-$LINENO}: result: -I" >&5
8160   $as_echo "-I" >&6; }
8161     elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
8162         MODDIRFLAG="-M"
8163         F90MODINCSPEC="-M<dir>"
8164 <       { $as_echo "$as_me:$LINENO: result: -M" >&5
8164 >       { $as_echo "$as_me:${as_lineno-$LINENO}: result: -M" >&5
8165   $as_echo "-M" >&6; }
8166     elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
8167         MODDIRFLAG="-p"
8168         F90MODINCSPEC="-p<dir>"
8169 <       { $as_echo "$as_me:$LINENO: result: -p" >&5
8169 >       { $as_echo "$as_me:${as_lineno-$LINENO}: result: -p" >&5
8170   $as_echo "-p" >&6; }
8171     elif test -s work.pc ; then
8172          cp work.pc conf/mpimod.pc
# Line 7248 | Line 8174 | $as_echo "-p" >&6; }
8174          echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
8175          if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
8176              MODDIRFLAG='-cl,mpimod.pcl'
8177 <            { $as_echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
8177 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: -cl,filename where filename contains a list of files and directories" >&5
8178   $as_echo "-cl,filename where filename contains a list of files and directories" >&6; }
8179              F90_WORK_FILES_ARG="-cl,mpimod.pcl"
8180              F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
# Line 7261 | Line 8187 | $as_echo "-cl,filename where filename contains a list
8187          fi
8188     fi
8189     if test -z "MODDIRFLAG" ; then
8190 <       { $as_echo "$as_me:$LINENO: result: unknown" >&5
8190 >       { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
8191   $as_echo "unknown" >&6; }
8192     fi
8193  
# Line 7271 | Line 8197 | fi
8197   fi
8198  
8199  
8200 < { $as_echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
8200 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Fortran 90 module file names" >&5
8201   $as_echo_n "checking for Fortran 90 module file names... " >&6; }
8202 < if test "${ac_cv_f90_module_names+set}" = set; then
8202 > if test "${ac_cv_f90_module_names+set}" = set; then :
8203    $as_echo_n "(cached) " >&6
8204   else
8205    ac_ext=${ac_fc_srcext-f}
# Line 7284 | Line 8210 | cd conftest
8210   # carry out the test in a new directory, so that we don't miss anything
8211   mkdir conftest
8212   cd conftest
8213 < cat >conftest.$ac_ext <<_ACEOF
8213 > cat > conftest.$ac_ext <<_ACEOF
8214   MODULE Bar
8215   END MODULE Bar
8216   _ACEOF
8217 < rm -f conftest.$ac_objext
7292 < if { (ac_try="$ac_compile"
7293 < case "(($ac_try" in
7294 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7295 <  *) ac_try_echo=$ac_try;;
7296 < esac
7297 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7298 < $as_echo "$ac_try_echo") >&5
7299 <  (eval "$ac_compile") 2>conftest.er1
7300 <  ac_status=$?
7301 <  grep -v '^ *+' conftest.er1 >conftest.err
7302 <  rm -f conftest.er1
7303 <  cat conftest.err >&5
7304 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7305 <  (exit $ac_status); } && {
7306 <         test -z "$ac_fc_werror_flag" ||
7307 <         test ! -s conftest.err
7308 <       } && test -s conftest.$ac_objext; then
8217 > if ac_fn_fc_try_compile "$LINENO"; then :
8218    ac_cv_f90_module_names=
8219   ac_file_list=*
8220   for ac_file in $ac_file_list; do
# Line 7325 | Line 8234 | for ac_file in $ac_file_list; do
8234      fi
8235    done
8236  
8237 <  if test x"$ac_exists" = xtrue; then
8238 <  :
8237 >  if test x"$ac_exists" = xtrue; then :
8238 >
8239   else
8240    ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8241   fi
7333 –
8242            ;;
8243        # look for new files derived from the module name,
8244        # with different case translation schemes
# Line 7344 | Line 8252 | fi
8252      fi
8253    done
8254  
8255 <  if test x"$ac_exists" = xtrue; then
8256 <  :
8255 >  if test x"$ac_exists" = xtrue; then :
8256 >
8257   else
8258    ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8259   fi
7352 –
8260            ;;
8261        *bar*)
8262            ac_pat=`echo $ac_file | sed s/bar/%module%/`
# Line 7361 | Line 8268 | fi
8268      fi
8269    done
8270  
8271 <  if test x"$ac_exists" = xtrue; then
8272 <  :
8271 >  if test x"$ac_exists" = xtrue; then :
8272 >
8273   else
8274    ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8275   fi
7369 –
8276            ;;
8277        *BAR*)
8278            ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
# Line 7378 | Line 8284 | fi
8284      fi
8285    done
8286  
8287 <  if test x"$ac_exists" = xtrue; then
8288 <  :
8287 >  if test x"$ac_exists" = xtrue; then :
8288 >
8289   else
8290    ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
8291   fi
7386 –
8292            ;;
8293         # Other files - we have no idea how they are generated
8294         *)
8295 <          { $as_echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
8295 >          { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Bogus file found: $ac_file" >&5
8296   $as_echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
8297            ;;
8298     esac
8299   done
8300   if test "x$ac_cv_f90_module_names" = "x"; then
8301 <  { $as_echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
8301 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Couldn't determine module file names" >&5
8302   $as_echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
8303   fi
8304  
8305   else
8306 <  $as_echo "$as_me: failed program was:" >&5
8307 < sed 's/^/| /' conftest.$ac_ext >&5
7403 <
7404 <        ac_cv_f90_module_names=
7405 < { $as_echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
8306 >  ac_cv_f90_module_names=
8307 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Couldn't determine module file names" >&5
8308   $as_echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
8309   fi
7408 –
8310   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8311   cd ..
8312   # cleanup
# Line 7416 | Line 8317 | fi
8317   ac_compiler_gnu=$ac_cv_fc_compiler_gnu
8318  
8319   fi
8320 < { $as_echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
8320 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_f90_module_names" >&5
8321   $as_echo "$ac_cv_f90_module_names" >&6; } # AC_CACHE_CHECK
8322  
8323   # We now generate a shell script that will help us to figure out the correct
# Line 7495 | Line 8396 | esac
8396            F90_MODULE_NAMES=unknown ;;
8397   esac
8398  
8399 < ac_ext=c
8400 < ac_cpp='$CPP $CPPFLAGS'
8401 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8402 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7502 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8399 > ac_ext=${ac_fc_srcext-f}
8400 > ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
8401 > ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
8402 > ac_compiler_gnu=$ac_cv_fc_compiler_gnu
8403  
8404  
8405   ac_ext=c
# Line 7509 | Line 8409 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
8409   ac_compiler_gnu=$ac_cv_c_compiler_gnu
8410  
8411  
8412 <
7513 < { $as_echo "$as_me:$LINENO: checking for asin in -lm" >&5
8412 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for asin in -lm" >&5
8413   $as_echo_n "checking for asin in -lm... " >&6; }
8414 < if test "${ac_cv_lib_m_asin+set}" = set; then
8414 > if test "${ac_cv_lib_m_asin+set}" = set; then :
8415    $as_echo_n "(cached) " >&6
8416   else
8417    ac_check_lib_save_LIBS=$LIBS
8418   LIBS="-lm  $LIBS"
8419 < cat >conftest.$ac_ext <<_ACEOF
7521 < /* confdefs.h.  */
7522 < _ACEOF
7523 < cat confdefs.h >>conftest.$ac_ext
7524 < cat >>conftest.$ac_ext <<_ACEOF
8419 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8420   /* end confdefs.h.  */
8421  
8422   /* Override any GCC internal prototype to avoid an error.
# Line 7547 | Line 8442 | _ACEOF
8442    return 0;
8443   }
8444   _ACEOF
8445 < rm -f conftest.$ac_objext conftest$ac_exeext
7551 < if { (ac_try="$ac_link"
7552 < case "(($ac_try" in
7553 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7554 <  *) ac_try_echo=$ac_try;;
7555 < esac
7556 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7557 < $as_echo "$ac_try_echo") >&5
7558 <  (eval "$ac_link") 2>conftest.er1
7559 <  ac_status=$?
7560 <  grep -v '^ *+' conftest.er1 >conftest.err
7561 <  rm -f conftest.er1
7562 <  cat conftest.err >&5
7563 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7564 <  (exit $ac_status); } && {
7565 <         test -z "$ac_c_werror_flag" ||
7566 <         test ! -s conftest.err
7567 <       } && test -s conftest$ac_exeext && {
7568 <         test "$cross_compiling" = yes ||
7569 <         $as_test_x conftest$ac_exeext
7570 <       }; then
8445 > if ac_fn_c_try_link "$LINENO"; then :
8446    ac_cv_lib_m_asin=yes
8447   else
8448 <  $as_echo "$as_me: failed program was:" >&5
7574 < sed 's/^/| /' conftest.$ac_ext >&5
7575 <
7576 <        ac_cv_lib_m_asin=no
8448 >  ac_cv_lib_m_asin=no
8449   fi
8450 <
8451 < rm -rf conftest.dSYM
7580 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7581 <      conftest$ac_exeext conftest.$ac_ext
8450 > rm -f core conftest.err conftest.$ac_objext \
8451 >    conftest$ac_exeext conftest.$ac_ext
8452   LIBS=$ac_check_lib_save_LIBS
8453   fi
8454 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
8454 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_asin" >&5
8455   $as_echo "$ac_cv_lib_m_asin" >&6; }
8456 < if test $ac_cv_lib_m_asin = yes; then
8456 > if test "x$ac_cv_lib_m_asin" = x""yes; then :
8457    cat >>confdefs.h <<_ACEOF
8458   #define HAVE_LIBM 1
8459   _ACEOF
# Line 7595 | Line 8465 | fi
8465   fi
8466  
8467  
8468 < { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
8468 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
8469   $as_echo_n "checking for ANSI C header files... " >&6; }
8470 < if test "${ac_cv_header_stdc+set}" = set; then
8470 > if test "${ac_cv_header_stdc+set}" = set; then :
8471    $as_echo_n "(cached) " >&6
8472   else
8473 <  cat >conftest.$ac_ext <<_ACEOF
7604 < /* confdefs.h.  */
7605 < _ACEOF
7606 < cat confdefs.h >>conftest.$ac_ext
7607 < cat >>conftest.$ac_ext <<_ACEOF
8473 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8474   /* end confdefs.h.  */
8475   #include <stdlib.h>
8476   #include <stdarg.h>
# Line 7627 | Line 8493 | _ACEOF
8493    return 0;
8494   }
8495   _ACEOF
8496 < rm -f conftest.$ac_objext
7631 < if { (ac_try="$ac_compile"
7632 < case "(($ac_try" in
7633 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7634 <  *) ac_try_echo=$ac_try;;
7635 < esac
7636 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7637 < $as_echo "$ac_try_echo") >&5
7638 <  (eval "$ac_compile") 2>conftest.er1
7639 <  ac_status=$?
7640 <  grep -v '^ *+' conftest.er1 >conftest.err
7641 <  rm -f conftest.er1
7642 <  cat conftest.err >&5
7643 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7644 <  (exit $ac_status); } && {
7645 <         test -z "$ac_c_werror_flag" ||
7646 <         test ! -s conftest.err
7647 <       } && test -s conftest.$ac_objext; then
8496 > if ac_fn_c_try_compile "$LINENO"; then :
8497    ac_cv_header_stdc=yes
8498   else
8499 <  $as_echo "$as_me: failed program was:" >&5
7651 < sed 's/^/| /' conftest.$ac_ext >&5
7652 <
7653 <        ac_cv_header_stdc=no
8499 >  ac_cv_header_stdc=no
8500   fi
7655 –
8501   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8502  
8503   if test $ac_cv_header_stdc = yes; then
8504    # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
8505 <  cat >conftest.$ac_ext <<_ACEOF
7661 < /* confdefs.h.  */
7662 < _ACEOF
7663 < cat confdefs.h >>conftest.$ac_ext
7664 < cat >>conftest.$ac_ext <<_ACEOF
8505 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8506   /* end confdefs.h.  */
8507   #include <string.h>
8508  
8509   _ACEOF
8510   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
8511 <  $EGREP "memchr" >/dev/null 2>&1; then
8512 <  :
8511 >  $EGREP "memchr" >/dev/null 2>&1; then :
8512 >
8513   else
8514    ac_cv_header_stdc=no
8515   fi
# Line 7678 | Line 8519 | if test $ac_cv_header_stdc = yes; then
8519  
8520   if test $ac_cv_header_stdc = yes; then
8521    # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
8522 <  cat >conftest.$ac_ext <<_ACEOF
7682 < /* confdefs.h.  */
7683 < _ACEOF
7684 < cat confdefs.h >>conftest.$ac_ext
7685 < cat >>conftest.$ac_ext <<_ACEOF
8522 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8523   /* end confdefs.h.  */
8524   #include <stdlib.h>
8525  
8526   _ACEOF
8527   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
8528 <  $EGREP "free" >/dev/null 2>&1; then
8529 <  :
8528 >  $EGREP "free" >/dev/null 2>&1; then :
8529 >
8530   else
8531    ac_cv_header_stdc=no
8532   fi
# Line 7699 | Line 8536 | if test $ac_cv_header_stdc = yes; then
8536  
8537   if test $ac_cv_header_stdc = yes; then
8538    # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
8539 <  if test "$cross_compiling" = yes; then
8539 >  if test "$cross_compiling" = yes; then :
8540    :
8541   else
8542 <  cat >conftest.$ac_ext <<_ACEOF
7706 < /* confdefs.h.  */
7707 < _ACEOF
7708 < cat confdefs.h >>conftest.$ac_ext
7709 < cat >>conftest.$ac_ext <<_ACEOF
8542 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8543   /* end confdefs.h.  */
8544   #include <ctype.h>
8545   #include <stdlib.h>
# Line 7733 | Line 8566 | _ACEOF
8566    return 0;
8567   }
8568   _ACEOF
8569 < rm -f conftest$ac_exeext
7737 < if { (ac_try="$ac_link"
7738 < case "(($ac_try" in
7739 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7740 <  *) ac_try_echo=$ac_try;;
7741 < esac
7742 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7743 < $as_echo "$ac_try_echo") >&5
7744 <  (eval "$ac_link") 2>&5
7745 <  ac_status=$?
7746 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7747 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7748 <  { (case "(($ac_try" in
7749 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7750 <  *) ac_try_echo=$ac_try;;
7751 < esac
7752 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7753 < $as_echo "$ac_try_echo") >&5
7754 <  (eval "$ac_try") 2>&5
7755 <  ac_status=$?
7756 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7757 <  (exit $ac_status); }; }; then
7758 <  :
7759 < else
7760 <  $as_echo "$as_me: program exited with status $ac_status" >&5
7761 < $as_echo "$as_me: failed program was:" >&5
7762 < sed 's/^/| /' conftest.$ac_ext >&5
8569 > if ac_fn_c_try_run "$LINENO"; then :
8570  
8571 < ( exit $ac_status )
8572 < ac_cv_header_stdc=no
8571 > else
8572 >  ac_cv_header_stdc=no
8573   fi
8574 < rm -rf conftest.dSYM
8575 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
8574 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
8575 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
8576   fi
8577  
7771 –
8578   fi
8579   fi
8580 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
8580 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
8581   $as_echo "$ac_cv_header_stdc" >&6; }
8582   if test $ac_cv_header_stdc = yes; then
8583  
8584 < cat >>confdefs.h <<\_ACEOF
7779 < #define STDC_HEADERS 1
7780 < _ACEOF
8584 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
8585  
8586   fi
8587  
8588   # On IRIX 5.3, sys/types and inttypes.h are conflicting.
7785 –
7786 –
7787 –
7788 –
7789 –
7790 –
7791 –
7792 –
7793 –
8589   for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
8590                    inttypes.h stdint.h unistd.h
8591 < do
8592 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
8593 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
8594 < $as_echo_n "checking for $ac_header... " >&6; }
8595 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
8596 <  $as_echo_n "(cached) " >&6
7802 < else
7803 <  cat >conftest.$ac_ext <<_ACEOF
7804 < /* confdefs.h.  */
7805 < _ACEOF
7806 < cat confdefs.h >>conftest.$ac_ext
7807 < cat >>conftest.$ac_ext <<_ACEOF
7808 < /* end confdefs.h.  */
7809 < $ac_includes_default
7810 <
7811 < #include <$ac_header>
7812 < _ACEOF
7813 < rm -f conftest.$ac_objext
7814 < if { (ac_try="$ac_compile"
7815 < case "(($ac_try" in
7816 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7817 <  *) ac_try_echo=$ac_try;;
7818 < esac
7819 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7820 < $as_echo "$ac_try_echo") >&5
7821 <  (eval "$ac_compile") 2>conftest.er1
7822 <  ac_status=$?
7823 <  grep -v '^ *+' conftest.er1 >conftest.err
7824 <  rm -f conftest.er1
7825 <  cat conftest.err >&5
7826 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7827 <  (exit $ac_status); } && {
7828 <         test -z "$ac_c_werror_flag" ||
7829 <         test ! -s conftest.err
7830 <       } && test -s conftest.$ac_objext; then
7831 <  eval "$as_ac_Header=yes"
7832 < else
7833 <  $as_echo "$as_me: failed program was:" >&5
7834 < sed 's/^/| /' conftest.$ac_ext >&5
7835 <
7836 <        eval "$as_ac_Header=no"
7837 < fi
7838 <
7839 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7840 < fi
7841 < ac_res=`eval 'as_val=${'$as_ac_Header'}
7842 <                 $as_echo "$as_val"'`
7843 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
7844 < $as_echo "$ac_res" >&6; }
7845 < if test `eval 'as_val=${'$as_ac_Header'}
7846 <                 $as_echo "$as_val"'` = yes; then
8591 > do :
8592 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
8593 > ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
8594 > "
8595 > eval as_val=\$$as_ac_Header
8596 >   if test "x$as_val" = x""yes; then :
8597    cat >>confdefs.h <<_ACEOF
8598   #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
8599   _ACEOF
# Line 7858 | Line 8608 | done
8608   #
8609  
8610   # Check whether --with-zlib was given.
8611 < if test "${with_zlib+set}" = set; then
8611 > if test "${with_zlib+set}" = set; then :
8612    withval=$with_zlib; zlib_dir="$withval"
8613   else
8614                  zlib_dir="not_set"
# Line 7871 | Line 8621 | if test "$zlib_dir" != "not_set" ; then
8621    then
8622      ZLIB_HOME="$zlib_dir"
8623    else
8624 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
8624 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
8625   $as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
8626          ZLIB_HOME=/usr/local
8627          if test ! -f "${ZLIB_HOME}/include/zlib.h"
# Line 7896 | Line 8646 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
8646   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8647   ac_compiler_gnu=$ac_cv_c_compiler_gnu
8648  
8649 <        { $as_echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
8649 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inflateEnd in -lz" >&5
8650   $as_echo_n "checking for inflateEnd in -lz... " >&6; }
8651 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
8651 > if test "${ac_cv_lib_z_inflateEnd+set}" = set; then :
8652    $as_echo_n "(cached) " >&6
8653   else
8654    ac_check_lib_save_LIBS=$LIBS
8655   LIBS="-lz  $LIBS"
8656 < cat >conftest.$ac_ext <<_ACEOF
7907 < /* confdefs.h.  */
7908 < _ACEOF
7909 < cat confdefs.h >>conftest.$ac_ext
7910 < cat >>conftest.$ac_ext <<_ACEOF
8656 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8657   /* end confdefs.h.  */
8658  
8659   /* Override any GCC internal prototype to avoid an error.
# Line 7933 | Line 8679 | _ACEOF
8679    return 0;
8680   }
8681   _ACEOF
8682 < rm -f conftest.$ac_objext conftest$ac_exeext
7937 < if { (ac_try="$ac_link"
7938 < case "(($ac_try" in
7939 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7940 <  *) ac_try_echo=$ac_try;;
7941 < esac
7942 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
7943 < $as_echo "$ac_try_echo") >&5
7944 <  (eval "$ac_link") 2>conftest.er1
7945 <  ac_status=$?
7946 <  grep -v '^ *+' conftest.er1 >conftest.err
7947 <  rm -f conftest.er1
7948 <  cat conftest.err >&5
7949 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
7950 <  (exit $ac_status); } && {
7951 <         test -z "$ac_c_werror_flag" ||
7952 <         test ! -s conftest.err
7953 <       } && test -s conftest$ac_exeext && {
7954 <         test "$cross_compiling" = yes ||
7955 <         $as_test_x conftest$ac_exeext
7956 <       }; then
8682 > if ac_fn_c_try_link "$LINENO"; then :
8683    ac_cv_lib_z_inflateEnd=yes
8684   else
8685 <  $as_echo "$as_me: failed program was:" >&5
7960 < sed 's/^/| /' conftest.$ac_ext >&5
7961 <
7962 <        ac_cv_lib_z_inflateEnd=no
8685 >  ac_cv_lib_z_inflateEnd=no
8686   fi
8687 <
8688 < rm -rf conftest.dSYM
7966 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7967 <      conftest$ac_exeext conftest.$ac_ext
8687 > rm -f core conftest.err conftest.$ac_objext \
8688 >    conftest$ac_exeext conftest.$ac_ext
8689   LIBS=$ac_check_lib_save_LIBS
8690   fi
8691 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
8691 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_inflateEnd" >&5
8692   $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
8693 < if test $ac_cv_lib_z_inflateEnd = yes; then
8693 > if test "x$ac_cv_lib_z_inflateEnd" = x""yes; then :
8694    zlib_cv_libz=yes
8695   else
8696    zlib_cv_libz=no
8697   fi
8698  
8699 <        if test "${ac_cv_header_zlib_h+set}" = set; then
8700 <  { $as_echo "$as_me:$LINENO: checking for zlib.h" >&5
7980 < $as_echo_n "checking for zlib.h... " >&6; }
7981 < if test "${ac_cv_header_zlib_h+set}" = set; then
7982 <  $as_echo_n "(cached) " >&6
7983 < fi
7984 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
7985 < $as_echo "$ac_cv_header_zlib_h" >&6; }
7986 < else
7987 <  # Is the header compilable?
7988 < { $as_echo "$as_me:$LINENO: checking zlib.h usability" >&5
7989 < $as_echo_n "checking zlib.h usability... " >&6; }
7990 < cat >conftest.$ac_ext <<_ACEOF
7991 < /* confdefs.h.  */
7992 < _ACEOF
7993 < cat confdefs.h >>conftest.$ac_ext
7994 < cat >>conftest.$ac_ext <<_ACEOF
7995 < /* end confdefs.h.  */
7996 < $ac_includes_default
7997 < #include <zlib.h>
7998 < _ACEOF
7999 < rm -f conftest.$ac_objext
8000 < if { (ac_try="$ac_compile"
8001 < case "(($ac_try" in
8002 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8003 <  *) ac_try_echo=$ac_try;;
8004 < esac
8005 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8006 < $as_echo "$ac_try_echo") >&5
8007 <  (eval "$ac_compile") 2>conftest.er1
8008 <  ac_status=$?
8009 <  grep -v '^ *+' conftest.er1 >conftest.err
8010 <  rm -f conftest.er1
8011 <  cat conftest.err >&5
8012 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8013 <  (exit $ac_status); } && {
8014 <         test -z "$ac_c_werror_flag" ||
8015 <         test ! -s conftest.err
8016 <       } && test -s conftest.$ac_objext; then
8017 <  ac_header_compiler=yes
8018 < else
8019 <  $as_echo "$as_me: failed program was:" >&5
8020 < sed 's/^/| /' conftest.$ac_ext >&5
8021 <
8022 <        ac_header_compiler=no
8023 < fi
8024 <
8025 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8026 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8027 < $as_echo "$ac_header_compiler" >&6; }
8028 <
8029 < # Is the header present?
8030 < { $as_echo "$as_me:$LINENO: checking zlib.h presence" >&5
8031 < $as_echo_n "checking zlib.h presence... " >&6; }
8032 < cat >conftest.$ac_ext <<_ACEOF
8033 < /* confdefs.h.  */
8034 < _ACEOF
8035 < cat confdefs.h >>conftest.$ac_ext
8036 < cat >>conftest.$ac_ext <<_ACEOF
8037 < /* end confdefs.h.  */
8038 < #include <zlib.h>
8039 < _ACEOF
8040 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8041 < case "(($ac_try" in
8042 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8043 <  *) ac_try_echo=$ac_try;;
8044 < esac
8045 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8046 < $as_echo "$ac_try_echo") >&5
8047 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8048 <  ac_status=$?
8049 <  grep -v '^ *+' conftest.er1 >conftest.err
8050 <  rm -f conftest.er1
8051 <  cat conftest.err >&5
8052 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8053 <  (exit $ac_status); } >/dev/null && {
8054 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8055 <         test ! -s conftest.err
8056 <       }; then
8057 <  ac_header_preproc=yes
8058 < else
8059 <  $as_echo "$as_me: failed program was:" >&5
8060 < sed 's/^/| /' conftest.$ac_ext >&5
8061 <
8062 <  ac_header_preproc=no
8063 < fi
8064 <
8065 < rm -f conftest.err conftest.$ac_ext
8066 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8067 < $as_echo "$ac_header_preproc" >&6; }
8068 <
8069 < # So?  What about this header?
8070 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8071 <  yes:no: )
8072 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
8073 < $as_echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8074 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
8075 < $as_echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
8076 <    ac_header_preproc=yes
8077 <    ;;
8078 <  no:yes:* )
8079 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
8080 < $as_echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
8081 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
8082 < $as_echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
8083 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
8084 < $as_echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
8085 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
8086 < $as_echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8087 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
8088 < $as_echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
8089 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
8090 < $as_echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
8091 <    ( cat <<\_ASBOX
8092 < ## ------------------------------ ##
8093 < ## Report this to gezelter@nd.edu ##
8094 < ## ------------------------------ ##
8095 < _ASBOX
8096 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8097 <    ;;
8098 < esac
8099 < { $as_echo "$as_me:$LINENO: checking for zlib.h" >&5
8100 < $as_echo_n "checking for zlib.h... " >&6; }
8101 < if test "${ac_cv_header_zlib_h+set}" = set; then
8102 <  $as_echo_n "(cached) " >&6
8103 < else
8104 <  ac_cv_header_zlib_h=$ac_header_preproc
8105 < fi
8106 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8107 < $as_echo "$ac_cv_header_zlib_h" >&6; }
8108 <
8109 < fi
8110 < if test $ac_cv_header_zlib_h = yes; then
8699 >        ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
8700 > if test "x$ac_cv_header_zlib_h" = x""yes; then :
8701    zlib_cv_zlib_h=yes
8702   else
8703    zlib_cv_zlib_h=no
# Line 8123 | Line 8713 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
8713  
8714          if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
8715  
8716 < cat >>confdefs.h <<\_ACEOF
8127 < #define HAVE_ZLIB_H 1
8128 < _ACEOF
8716 > $as_echo "#define HAVE_ZLIB_H 1" >>confdefs.h
8717  
8718  
8719 < cat >>confdefs.h <<\_ACEOF
8132 < #define HAVE_LIBZ 1
8133 < _ACEOF
8719 > $as_echo "#define HAVE_LIBZ 1" >>confdefs.h
8720  
8721                  ZLIB_INC_DIR="${ZLIB_HOME}/include"
8722                  ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
8723                  ZLIB="-lz"
8724          else
8725 <                { $as_echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
8725 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking zlib in ${ZLIB_HOME}" >&5
8726   $as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
8727                  ZLIB_INC_DIR=
8728                  ZLIB_LIB_DIR=
8729                  ZLIB=
8730                  LDFLAGS="$ZLIB_OLD_LDFLAGS"
8731                  CFLAGS="$ZLIB_OLD_CFLAGS"
8732 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
8732 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
8733   $as_echo "failed" >&6; }
8734                  echo ""
8735                  echo "*********************************************************"
# Line 8167 | Line 8753 | fi
8753   #
8754  
8755   # Check whether --with-fftw was given.
8756 < if test "${with_fftw+set}" = set; then
8756 > if test "${with_fftw+set}" = set; then :
8757    withval=$with_fftw; fftw_dir="$withval"
8758   else
8759               fftw_dir="not_set"
# Line 8178 | Line 8764 | if test "$fftw_dir" != "no"; then
8764      if test -d "$fftw_dir"; then
8765        FFTW_HOME="$fftw_dir"
8766      else
8767 <      { $as_echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
8767 >      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
8768   $as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
8769        FFTW_HOME=/usr/local
8770        if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
# Line 8200 | Line 8786 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
8786   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8787   ac_compiler_gnu=$ac_cv_c_compiler_gnu
8788  
8789 <      { $as_echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
8789 >      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
8790   $as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
8791 < if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
8791 > if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then :
8792    $as_echo_n "(cached) " >&6
8793   else
8794    ac_check_lib_save_LIBS=$LIBS
8795   LIBS="-lfftw3  $LIBS"
8796 < cat >conftest.$ac_ext <<_ACEOF
8211 < /* confdefs.h.  */
8212 < _ACEOF
8213 < cat confdefs.h >>conftest.$ac_ext
8214 < cat >>conftest.$ac_ext <<_ACEOF
8796 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8797   /* end confdefs.h.  */
8798  
8799   /* Override any GCC internal prototype to avoid an error.
# Line 8221 | Line 8803 | char fftw_execute ();
8803   extern "C"
8804   #endif
8805   char fftw_execute ();
8806 < #ifdef FC_DUMMY_MAIN
8807 < #ifndef FC_DUMMY_MAIN_EQ_F77
8808 < #  ifdef __cplusplus
8809 <     extern "C"
8810 < #  endif
8811 <   int FC_DUMMY_MAIN() { return 1; }
8812 < #endif
8813 < #endif
8814 < int
8815 < main ()
8816 < {
8817 < return fftw_execute ();
8818 <  ;
8819 <  return 0;
8820 < }
8821 < _ACEOF
8822 < rm -f conftest.$ac_objext conftest$ac_exeext
8823 < if { (ac_try="$ac_link"
8242 < case "(($ac_try" in
8243 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8244 <  *) ac_try_echo=$ac_try;;
8245 < esac
8246 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8247 < $as_echo "$ac_try_echo") >&5
8248 <  (eval "$ac_link") 2>conftest.er1
8249 <  ac_status=$?
8250 <  grep -v '^ *+' conftest.er1 >conftest.err
8251 <  rm -f conftest.er1
8252 <  cat conftest.err >&5
8253 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8254 <  (exit $ac_status); } && {
8255 <         test -z "$ac_c_werror_flag" ||
8256 <         test ! -s conftest.err
8257 <       } && test -s conftest$ac_exeext && {
8258 <         test "$cross_compiling" = yes ||
8259 <         $as_test_x conftest$ac_exeext
8260 <       }; then
8261 <  ac_cv_lib_fftw3_fftw_execute=yes
8262 < else
8263 <  $as_echo "$as_me: failed program was:" >&5
8264 < sed 's/^/| /' conftest.$ac_ext >&5
8265 <
8266 <        ac_cv_lib_fftw3_fftw_execute=no
8267 < fi
8268 <
8269 < rm -rf conftest.dSYM
8270 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8271 <      conftest$ac_exeext conftest.$ac_ext
8272 < LIBS=$ac_check_lib_save_LIBS
8273 < fi
8274 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
8275 < $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
8276 < if test $ac_cv_lib_fftw3_fftw_execute = yes; then
8277 <  fftw_cv_libfftw3=yes
8278 < else
8279 <  fftw_cv_libfftw3=no
8280 < fi
8281 <
8282 <      if test "${ac_cv_header_fftw3_h+set}" = set; then
8283 <  { $as_echo "$as_me:$LINENO: checking for fftw3.h" >&5
8284 < $as_echo_n "checking for fftw3.h... " >&6; }
8285 < if test "${ac_cv_header_fftw3_h+set}" = set; then
8286 <  $as_echo_n "(cached) " >&6
8287 < fi
8288 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8289 < $as_echo "$ac_cv_header_fftw3_h" >&6; }
8290 < else
8291 <  # Is the header compilable?
8292 < { $as_echo "$as_me:$LINENO: checking fftw3.h usability" >&5
8293 < $as_echo_n "checking fftw3.h usability... " >&6; }
8294 < cat >conftest.$ac_ext <<_ACEOF
8295 < /* confdefs.h.  */
8296 < _ACEOF
8297 < cat confdefs.h >>conftest.$ac_ext
8298 < cat >>conftest.$ac_ext <<_ACEOF
8299 < /* end confdefs.h.  */
8300 < $ac_includes_default
8301 < #include <fftw3.h>
8302 < _ACEOF
8303 < rm -f conftest.$ac_objext
8304 < if { (ac_try="$ac_compile"
8305 < case "(($ac_try" in
8306 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8307 <  *) ac_try_echo=$ac_try;;
8308 < esac
8309 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8310 < $as_echo "$ac_try_echo") >&5
8311 <  (eval "$ac_compile") 2>conftest.er1
8312 <  ac_status=$?
8313 <  grep -v '^ *+' conftest.er1 >conftest.err
8314 <  rm -f conftest.er1
8315 <  cat conftest.err >&5
8316 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8317 <  (exit $ac_status); } && {
8318 <         test -z "$ac_c_werror_flag" ||
8319 <         test ! -s conftest.err
8320 <       } && test -s conftest.$ac_objext; then
8321 <  ac_header_compiler=yes
8322 < else
8323 <  $as_echo "$as_me: failed program was:" >&5
8324 < sed 's/^/| /' conftest.$ac_ext >&5
8325 <
8326 <        ac_header_compiler=no
8327 < fi
8328 <
8329 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8330 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8331 < $as_echo "$ac_header_compiler" >&6; }
8332 <
8333 < # Is the header present?
8334 < { $as_echo "$as_me:$LINENO: checking fftw3.h presence" >&5
8335 < $as_echo_n "checking fftw3.h presence... " >&6; }
8336 < cat >conftest.$ac_ext <<_ACEOF
8337 < /* confdefs.h.  */
8338 < _ACEOF
8339 < cat confdefs.h >>conftest.$ac_ext
8340 < cat >>conftest.$ac_ext <<_ACEOF
8341 < /* end confdefs.h.  */
8342 < #include <fftw3.h>
8343 < _ACEOF
8344 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8345 < case "(($ac_try" in
8346 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8347 <  *) ac_try_echo=$ac_try;;
8348 < esac
8349 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8350 < $as_echo "$ac_try_echo") >&5
8351 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8352 <  ac_status=$?
8353 <  grep -v '^ *+' conftest.er1 >conftest.err
8354 <  rm -f conftest.er1
8355 <  cat conftest.err >&5
8356 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8357 <  (exit $ac_status); } >/dev/null && {
8358 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8359 <         test ! -s conftest.err
8360 <       }; then
8361 <  ac_header_preproc=yes
8362 < else
8363 <  $as_echo "$as_me: failed program was:" >&5
8364 < sed 's/^/| /' conftest.$ac_ext >&5
8365 <
8366 <  ac_header_preproc=no
8367 < fi
8368 <
8369 < rm -f conftest.err conftest.$ac_ext
8370 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8371 < $as_echo "$ac_header_preproc" >&6; }
8372 <
8373 < # So?  What about this header?
8374 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8375 <  yes:no: )
8376 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
8377 < $as_echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8378 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
8379 < $as_echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
8380 <    ac_header_preproc=yes
8381 <    ;;
8382 <  no:yes:* )
8383 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
8384 < $as_echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
8385 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
8386 < $as_echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
8387 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
8388 < $as_echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
8389 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
8390 < $as_echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8391 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
8392 < $as_echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
8393 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
8394 < $as_echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
8395 <    ( cat <<\_ASBOX
8396 < ## ------------------------------ ##
8397 < ## Report this to gezelter@nd.edu ##
8398 < ## ------------------------------ ##
8399 < _ASBOX
8400 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8401 <    ;;
8402 < esac
8403 < { $as_echo "$as_me:$LINENO: checking for fftw3.h" >&5
8404 < $as_echo_n "checking for fftw3.h... " >&6; }
8405 < if test "${ac_cv_header_fftw3_h+set}" = set; then
8406 <  $as_echo_n "(cached) " >&6
8806 > #ifdef FC_DUMMY_MAIN
8807 > #ifndef FC_DUMMY_MAIN_EQ_F77
8808 > #  ifdef __cplusplus
8809 >     extern "C"
8810 > #  endif
8811 >   int FC_DUMMY_MAIN() { return 1; }
8812 > #endif
8813 > #endif
8814 > int
8815 > main ()
8816 > {
8817 > return fftw_execute ();
8818 >  ;
8819 >  return 0;
8820 > }
8821 > _ACEOF
8822 > if ac_fn_c_try_link "$LINENO"; then :
8823 >  ac_cv_lib_fftw3_fftw_execute=yes
8824   else
8825 <  ac_cv_header_fftw3_h=$ac_header_preproc
8825 >  ac_cv_lib_fftw3_fftw_execute=no
8826   fi
8827 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8828 < $as_echo "$ac_cv_header_fftw3_h" >&6; }
8829 <
8827 > rm -f core conftest.err conftest.$ac_objext \
8828 >    conftest$ac_exeext conftest.$ac_ext
8829 > LIBS=$ac_check_lib_save_LIBS
8830   fi
8831 < if test $ac_cv_header_fftw3_h = yes; then
8831 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
8832 > $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
8833 > if test "x$ac_cv_lib_fftw3_fftw_execute" = x""yes; then :
8834 >  fftw_cv_libfftw3=yes
8835 > else
8836 >  fftw_cv_libfftw3=no
8837 > fi
8838 >
8839 >      ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
8840 > if test "x$ac_cv_header_fftw3_h" = x""yes; then :
8841    fftw_cv_fftw3_h=yes
8842   else
8843    fftw_cv_fftw3_h=no
# Line 8419 | Line 8845 | fi
8845  
8846  
8847        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
8848 <        { $as_echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
8848 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -lfftw" >&5
8849   $as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
8850 < if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
8850 > if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then :
8851    $as_echo_n "(cached) " >&6
8852   else
8853    ac_check_lib_save_LIBS=$LIBS
8854   LIBS="-lfftw  $LIBS"
8855 < cat >conftest.$ac_ext <<_ACEOF
8430 < /* confdefs.h.  */
8431 < _ACEOF
8432 < cat confdefs.h >>conftest.$ac_ext
8433 < cat >>conftest.$ac_ext <<_ACEOF
8855 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8856   /* end confdefs.h.  */
8857  
8858   /* Override any GCC internal prototype to avoid an error.
# Line 8456 | Line 8878 | _ACEOF
8878    return 0;
8879   }
8880   _ACEOF
8881 < rm -f conftest.$ac_objext conftest$ac_exeext
8460 < if { (ac_try="$ac_link"
8461 < case "(($ac_try" in
8462 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8463 <  *) ac_try_echo=$ac_try;;
8464 < esac
8465 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8466 < $as_echo "$ac_try_echo") >&5
8467 <  (eval "$ac_link") 2>conftest.er1
8468 <  ac_status=$?
8469 <  grep -v '^ *+' conftest.er1 >conftest.err
8470 <  rm -f conftest.er1
8471 <  cat conftest.err >&5
8472 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8473 <  (exit $ac_status); } && {
8474 <         test -z "$ac_c_werror_flag" ||
8475 <         test ! -s conftest.err
8476 <       } && test -s conftest$ac_exeext && {
8477 <         test "$cross_compiling" = yes ||
8478 <         $as_test_x conftest$ac_exeext
8479 <       }; then
8881 > if ac_fn_c_try_link "$LINENO"; then :
8882    ac_cv_lib_fftw_fftwnd_one=yes
8883   else
8884 <  $as_echo "$as_me: failed program was:" >&5
8483 < sed 's/^/| /' conftest.$ac_ext >&5
8484 <
8485 <        ac_cv_lib_fftw_fftwnd_one=no
8884 >  ac_cv_lib_fftw_fftwnd_one=no
8885   fi
8886 <
8887 < rm -rf conftest.dSYM
8489 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8490 <      conftest$ac_exeext conftest.$ac_ext
8886 > rm -f core conftest.err conftest.$ac_objext \
8887 >    conftest$ac_exeext conftest.$ac_ext
8888   LIBS=$ac_check_lib_save_LIBS
8889   fi
8890 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
8890 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw_fftwnd_one" >&5
8891   $as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
8892 < if test $ac_cv_lib_fftw_fftwnd_one = yes; then
8892 > if test "x$ac_cv_lib_fftw_fftwnd_one" = x""yes; then :
8893    fftw_cv_libfftw=yes
8894   else
8895    fftw_cv_libfftw=no
8896   fi
8897  
8898 <        if test "${ac_cv_header_fftw_h+set}" = set; then
8899 <  { $as_echo "$as_me:$LINENO: checking for fftw.h" >&5
8503 < $as_echo_n "checking for fftw.h... " >&6; }
8504 < if test "${ac_cv_header_fftw_h+set}" = set; then
8505 <  $as_echo_n "(cached) " >&6
8506 < fi
8507 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
8508 < $as_echo "$ac_cv_header_fftw_h" >&6; }
8509 < else
8510 <  # Is the header compilable?
8511 < { $as_echo "$as_me:$LINENO: checking fftw.h usability" >&5
8512 < $as_echo_n "checking fftw.h usability... " >&6; }
8513 < cat >conftest.$ac_ext <<_ACEOF
8514 < /* confdefs.h.  */
8515 < _ACEOF
8516 < cat confdefs.h >>conftest.$ac_ext
8517 < cat >>conftest.$ac_ext <<_ACEOF
8518 < /* end confdefs.h.  */
8519 < $ac_includes_default
8520 < #include <fftw.h>
8521 < _ACEOF
8522 < rm -f conftest.$ac_objext
8523 < if { (ac_try="$ac_compile"
8524 < case "(($ac_try" in
8525 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8526 <  *) ac_try_echo=$ac_try;;
8527 < esac
8528 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8529 < $as_echo "$ac_try_echo") >&5
8530 <  (eval "$ac_compile") 2>conftest.er1
8531 <  ac_status=$?
8532 <  grep -v '^ *+' conftest.er1 >conftest.err
8533 <  rm -f conftest.er1
8534 <  cat conftest.err >&5
8535 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8536 <  (exit $ac_status); } && {
8537 <         test -z "$ac_c_werror_flag" ||
8538 <         test ! -s conftest.err
8539 <       } && test -s conftest.$ac_objext; then
8540 <  ac_header_compiler=yes
8541 < else
8542 <  $as_echo "$as_me: failed program was:" >&5
8543 < sed 's/^/| /' conftest.$ac_ext >&5
8544 <
8545 <        ac_header_compiler=no
8546 < fi
8547 <
8548 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8549 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8550 < $as_echo "$ac_header_compiler" >&6; }
8551 <
8552 < # Is the header present?
8553 < { $as_echo "$as_me:$LINENO: checking fftw.h presence" >&5
8554 < $as_echo_n "checking fftw.h presence... " >&6; }
8555 < cat >conftest.$ac_ext <<_ACEOF
8556 < /* confdefs.h.  */
8557 < _ACEOF
8558 < cat confdefs.h >>conftest.$ac_ext
8559 < cat >>conftest.$ac_ext <<_ACEOF
8560 < /* end confdefs.h.  */
8561 < #include <fftw.h>
8562 < _ACEOF
8563 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8564 < case "(($ac_try" in
8565 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8566 <  *) ac_try_echo=$ac_try;;
8567 < esac
8568 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8569 < $as_echo "$ac_try_echo") >&5
8570 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8571 <  ac_status=$?
8572 <  grep -v '^ *+' conftest.er1 >conftest.err
8573 <  rm -f conftest.er1
8574 <  cat conftest.err >&5
8575 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8576 <  (exit $ac_status); } >/dev/null && {
8577 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8578 <         test ! -s conftest.err
8579 <       }; then
8580 <  ac_header_preproc=yes
8581 < else
8582 <  $as_echo "$as_me: failed program was:" >&5
8583 < sed 's/^/| /' conftest.$ac_ext >&5
8584 <
8585 <  ac_header_preproc=no
8586 < fi
8587 <
8588 < rm -f conftest.err conftest.$ac_ext
8589 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8590 < $as_echo "$ac_header_preproc" >&6; }
8591 <
8592 < # So?  What about this header?
8593 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8594 <  yes:no: )
8595 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
8596 < $as_echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8597 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
8598 < $as_echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
8599 <    ac_header_preproc=yes
8600 <    ;;
8601 <  no:yes:* )
8602 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
8603 < $as_echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
8604 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
8605 < $as_echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
8606 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
8607 < $as_echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
8608 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
8609 < $as_echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8610 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
8611 < $as_echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
8612 <    { $as_echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
8613 < $as_echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
8614 <    ( cat <<\_ASBOX
8615 < ## ------------------------------ ##
8616 < ## Report this to gezelter@nd.edu ##
8617 < ## ------------------------------ ##
8618 < _ASBOX
8619 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8620 <    ;;
8621 < esac
8622 < { $as_echo "$as_me:$LINENO: checking for fftw.h" >&5
8623 < $as_echo_n "checking for fftw.h... " >&6; }
8624 < if test "${ac_cv_header_fftw_h+set}" = set; then
8625 <  $as_echo_n "(cached) " >&6
8626 < else
8627 <  ac_cv_header_fftw_h=$ac_header_preproc
8628 < fi
8629 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
8630 < $as_echo "$ac_cv_header_fftw_h" >&6; }
8631 <
8632 < fi
8633 < if test $ac_cv_header_fftw_h = yes; then
8898 >        ac_fn_c_check_header_mongrel "$LINENO" "fftw.h" "ac_cv_header_fftw_h" "$ac_includes_default"
8899 > if test "x$ac_cv_header_fftw_h" = x""yes; then :
8900    fftw_cv_fftw_h=yes
8901   else
8902    fftw_cv_fftw_h=no
# Line 8638 | Line 8904 | fi
8904  
8905  
8906          if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
8907 <          { $as_echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
8907 >          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -ldfftw" >&5
8908   $as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
8909 < if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
8909 > if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then :
8910    $as_echo_n "(cached) " >&6
8911   else
8912    ac_check_lib_save_LIBS=$LIBS
8913   LIBS="-ldfftw  $LIBS"
8914 < cat >conftest.$ac_ext <<_ACEOF
8649 < /* confdefs.h.  */
8650 < _ACEOF
8651 < cat confdefs.h >>conftest.$ac_ext
8652 < cat >>conftest.$ac_ext <<_ACEOF
8914 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
8915   /* end confdefs.h.  */
8916  
8917   /* Override any GCC internal prototype to avoid an error.
# Line 8675 | Line 8937 | _ACEOF
8937    return 0;
8938   }
8939   _ACEOF
8940 < rm -f conftest.$ac_objext conftest$ac_exeext
8679 < if { (ac_try="$ac_link"
8680 < case "(($ac_try" in
8681 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8682 <  *) ac_try_echo=$ac_try;;
8683 < esac
8684 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8685 < $as_echo "$ac_try_echo") >&5
8686 <  (eval "$ac_link") 2>conftest.er1
8687 <  ac_status=$?
8688 <  grep -v '^ *+' conftest.er1 >conftest.err
8689 <  rm -f conftest.er1
8690 <  cat conftest.err >&5
8691 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8692 <  (exit $ac_status); } && {
8693 <         test -z "$ac_c_werror_flag" ||
8694 <         test ! -s conftest.err
8695 <       } && test -s conftest$ac_exeext && {
8696 <         test "$cross_compiling" = yes ||
8697 <         $as_test_x conftest$ac_exeext
8698 <       }; then
8940 > if ac_fn_c_try_link "$LINENO"; then :
8941    ac_cv_lib_dfftw_fftwnd_one=yes
8942   else
8943 <  $as_echo "$as_me: failed program was:" >&5
8702 < sed 's/^/| /' conftest.$ac_ext >&5
8703 <
8704 <        ac_cv_lib_dfftw_fftwnd_one=no
8943 >  ac_cv_lib_dfftw_fftwnd_one=no
8944   fi
8945 <
8946 < rm -rf conftest.dSYM
8708 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8709 <      conftest$ac_exeext conftest.$ac_ext
8945 > rm -f core conftest.err conftest.$ac_objext \
8946 >    conftest$ac_exeext conftest.$ac_ext
8947   LIBS=$ac_check_lib_save_LIBS
8948   fi
8949 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
8949 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
8950   $as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
8951 < if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
8951 > if test "x$ac_cv_lib_dfftw_fftwnd_one" = x""yes; then :
8952    fftw_cv_libdfftw=yes
8953   else
8954    fftw_cv_libdfftw=no
8955   fi
8956  
8957 <          if test "${ac_cv_header_dfftw_h+set}" = set; then
8958 <  { $as_echo "$as_me:$LINENO: checking for dfftw.h" >&5
8722 < $as_echo_n "checking for dfftw.h... " >&6; }
8723 < if test "${ac_cv_header_dfftw_h+set}" = set; then
8724 <  $as_echo_n "(cached) " >&6
8725 < fi
8726 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
8727 < $as_echo "$ac_cv_header_dfftw_h" >&6; }
8728 < else
8729 <  # Is the header compilable?
8730 < { $as_echo "$as_me:$LINENO: checking dfftw.h usability" >&5
8731 < $as_echo_n "checking dfftw.h usability... " >&6; }
8732 < cat >conftest.$ac_ext <<_ACEOF
8733 < /* confdefs.h.  */
8734 < _ACEOF
8735 < cat confdefs.h >>conftest.$ac_ext
8736 < cat >>conftest.$ac_ext <<_ACEOF
8737 < /* end confdefs.h.  */
8738 < $ac_includes_default
8739 < #include <dfftw.h>
8740 < _ACEOF
8741 < rm -f conftest.$ac_objext
8742 < if { (ac_try="$ac_compile"
8743 < case "(($ac_try" in
8744 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8745 <  *) ac_try_echo=$ac_try;;
8746 < esac
8747 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8748 < $as_echo "$ac_try_echo") >&5
8749 <  (eval "$ac_compile") 2>conftest.er1
8750 <  ac_status=$?
8751 <  grep -v '^ *+' conftest.er1 >conftest.err
8752 <  rm -f conftest.er1
8753 <  cat conftest.err >&5
8754 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8755 <  (exit $ac_status); } && {
8756 <         test -z "$ac_c_werror_flag" ||
8757 <         test ! -s conftest.err
8758 <       } && test -s conftest.$ac_objext; then
8759 <  ac_header_compiler=yes
8760 < else
8761 <  $as_echo "$as_me: failed program was:" >&5
8762 < sed 's/^/| /' conftest.$ac_ext >&5
8763 <
8764 <        ac_header_compiler=no
8765 < fi
8766 <
8767 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8768 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8769 < $as_echo "$ac_header_compiler" >&6; }
8770 <
8771 < # Is the header present?
8772 < { $as_echo "$as_me:$LINENO: checking dfftw.h presence" >&5
8773 < $as_echo_n "checking dfftw.h presence... " >&6; }
8774 < cat >conftest.$ac_ext <<_ACEOF
8775 < /* confdefs.h.  */
8776 < _ACEOF
8777 < cat confdefs.h >>conftest.$ac_ext
8778 < cat >>conftest.$ac_ext <<_ACEOF
8779 < /* end confdefs.h.  */
8780 < #include <dfftw.h>
8781 < _ACEOF
8782 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8783 < case "(($ac_try" in
8784 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8785 <  *) ac_try_echo=$ac_try;;
8786 < esac
8787 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8788 < $as_echo "$ac_try_echo") >&5
8789 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8790 <  ac_status=$?
8791 <  grep -v '^ *+' conftest.er1 >conftest.err
8792 <  rm -f conftest.er1
8793 <  cat conftest.err >&5
8794 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8795 <  (exit $ac_status); } >/dev/null && {
8796 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8797 <         test ! -s conftest.err
8798 <       }; then
8799 <  ac_header_preproc=yes
8800 < else
8801 <  $as_echo "$as_me: failed program was:" >&5
8802 < sed 's/^/| /' conftest.$ac_ext >&5
8803 <
8804 <  ac_header_preproc=no
8805 < fi
8806 <
8807 < rm -f conftest.err conftest.$ac_ext
8808 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8809 < $as_echo "$ac_header_preproc" >&6; }
8810 <
8811 < # So?  What about this header?
8812 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8813 <  yes:no: )
8814 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
8815 < $as_echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8816 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
8817 < $as_echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
8818 <    ac_header_preproc=yes
8819 <    ;;
8820 <  no:yes:* )
8821 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
8822 < $as_echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
8823 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
8824 < $as_echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
8825 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
8826 < $as_echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
8827 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
8828 < $as_echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8829 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
8830 < $as_echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
8831 <    { $as_echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
8832 < $as_echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
8833 <    ( cat <<\_ASBOX
8834 < ## ------------------------------ ##
8835 < ## Report this to gezelter@nd.edu ##
8836 < ## ------------------------------ ##
8837 < _ASBOX
8838 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8839 <    ;;
8840 < esac
8841 < { $as_echo "$as_me:$LINENO: checking for dfftw.h" >&5
8842 < $as_echo_n "checking for dfftw.h... " >&6; }
8843 < if test "${ac_cv_header_dfftw_h+set}" = set; then
8844 <  $as_echo_n "(cached) " >&6
8845 < else
8846 <  ac_cv_header_dfftw_h=$ac_header_preproc
8847 < fi
8848 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
8849 < $as_echo "$ac_cv_header_dfftw_h" >&6; }
8850 <
8851 < fi
8852 < if test $ac_cv_header_dfftw_h = yes; then
8957 >          ac_fn_c_check_header_mongrel "$LINENO" "dfftw.h" "ac_cv_header_dfftw_h" "$ac_includes_default"
8958 > if test "x$ac_cv_header_dfftw_h" = x""yes; then :
8959    fftw_cv_dfftw_h=yes
8960   else
8961    fftw_cv_dfftw_h=no
# Line 8866 | Line 8972 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
8972  
8973        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
8974  
8975 < cat >>confdefs.h <<\_ACEOF
8870 < #define HAVE_FFTW3_H 1
8871 < _ACEOF
8975 > $as_echo "#define HAVE_FFTW3_H 1" >>confdefs.h
8976  
8977          FFTW_INC_DIR="${FFTW_HOME}/include"
8978          FFTW_LIB_DIR="${FFTW_HOME}/lib"
# Line 8876 | Line 8980 | _ACEOF
8980        else
8981          if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
8982  
8983 < cat >>confdefs.h <<\_ACEOF
8880 < #define HAVE_FFTW_H 1
8881 < _ACEOF
8983 > $as_echo "#define HAVE_FFTW_H 1" >>confdefs.h
8984  
8985            FFTW_INC_DIR="${FFTW_HOME}/include"
8986            FFTW_LIB_DIR="${FFTW_HOME}/lib"
# Line 8886 | Line 8988 | _ACEOF
8988          else
8989            if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
8990  
8991 < cat >>confdefs.h <<\_ACEOF
8890 < #define HAVE_DFFTW_H 1
8891 < _ACEOF
8991 > $as_echo "#define HAVE_DFFTW_H 1" >>confdefs.h
8992  
8993              FFTW_INC_DIR="${FFTW_HOME}/include"
8994              FFTW_LIB_DIR="${FFTW_HOME}/lib"
8995              FFTW_LIBS="-ldfftw"
8996            else
8997 <            { $as_echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
8997 >            { $as_echo "$as_me:${as_lineno-$LINENO}: checking fftw in ${FFTW_HOME}" >&5
8998   $as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
8999              FFTW_INC_DIR=
9000              FFTW_LIB_DIR=
9001              FFTW_LIBS=
9002              LDFLAGS="$FFTW_OLD_LDFLAGS"
9003              CFLAGS="$FFTW_OLD_CFLAGS"
9004 <            { $as_echo "$as_me:$LINENO: result: failed" >&5
9004 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
9005   $as_echo "failed" >&6; }
9006              echo ""
9007              echo "*********************************************************"
# Line 8928 | Line 9028 | fi
9028   #
9029  
9030   # Check whether --with-qhull was given.
9031 < if test "${with_qhull+set}" = set; then
9031 > if test "${with_qhull+set}" = set; then :
9032    withval=$with_qhull; qhull_dir="$withval"
9033   else
9034 <                qhull_dir="not_set"
9034 >  qhull_dir="not_set"
9035   fi
9036  
9037 < if test "$qhull_dir" != "no"; then
9037 > QHULL_INC_DIR=
9038 > QHULL_LIB_DIR=
9039 > QHULL=
9040 > USE_QHULL=no
9041  
9042 < if test "$qhull_dir" != "not_set" ; then
9043 <  if test -d "$qhull_dir"
9044 <  then
9045 <    QHULL_HOME="$qhull_dir"
9046 <  else
9047 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
9042 > if test "$qhull_dir" != "no"; then
9043 >   if test "$qhull_dir" != "not_set" ; then
9044 >     if test -d "$qhull_dir"; then
9045 >       QHULL_HOME="$qhull_dir"
9046 >     else
9047 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
9048   $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
9049 <        QHULL_HOME=/usr/local
9050 <        if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"
9051 <        then
9052 <                QHULL_HOME=/usr
9053 <        fi
9054 <  fi
9055 < fi
9056 < #
9057 < # Locate qhull, if wanted
9058 < #
9059 < if test -n "${QHULL_HOME}"
9060 < then
9049 >       QHULL_HOME=/usr/local
9050 >       if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"; then
9051 >          QHULL_HOME=/usr
9052 >       fi
9053 >     fi
9054 >   fi
9055 >   #
9056 >   # Locate qhull, if wanted
9057 >   #
9058 >   if test -n "${QHULL_HOME}"; then
9059 >        { $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
9060 > $as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
9061  
9062          ac_ext=c
9063   ac_cpp='$CPP $CPPFLAGS'
# Line 8968 | Line 9071 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
9071          LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
9072          CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
9073          CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
9074 <        if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
9075 <  { $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
8973 < $as_echo_n "checking for qhull/qhull.h... " >&6; }
8974 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8975 <  $as_echo_n "(cached) " >&6
8976 < fi
8977 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
8978 < $as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
8979 < else
8980 <  # Is the header compilable?
8981 < { $as_echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
8982 < $as_echo_n "checking qhull/qhull.h usability... " >&6; }
8983 < cat >conftest.$ac_ext <<_ACEOF
8984 < /* confdefs.h.  */
8985 < _ACEOF
8986 < cat confdefs.h >>conftest.$ac_ext
8987 < cat >>conftest.$ac_ext <<_ACEOF
8988 < /* end confdefs.h.  */
8989 < $ac_includes_default
8990 < #include <qhull/qhull.h>
8991 < _ACEOF
8992 < rm -f conftest.$ac_objext
8993 < if { (ac_try="$ac_compile"
8994 < case "(($ac_try" in
8995 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8996 <  *) ac_try_echo=$ac_try;;
8997 < esac
8998 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8999 < $as_echo "$ac_try_echo") >&5
9000 <  (eval "$ac_compile") 2>conftest.er1
9001 <  ac_status=$?
9002 <  grep -v '^ *+' conftest.er1 >conftest.err
9003 <  rm -f conftest.er1
9004 <  cat conftest.err >&5
9005 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9006 <  (exit $ac_status); } && {
9007 <         test -z "$ac_c_werror_flag" ||
9008 <         test ! -s conftest.err
9009 <       } && test -s conftest.$ac_objext; then
9010 <  ac_header_compiler=yes
9011 < else
9012 <  $as_echo "$as_me: failed program was:" >&5
9013 < sed 's/^/| /' conftest.$ac_ext >&5
9014 <
9015 <        ac_header_compiler=no
9016 < fi
9017 <
9018 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9019 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9020 < $as_echo "$ac_header_compiler" >&6; }
9021 <
9022 < # Is the header present?
9023 < { $as_echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
9024 < $as_echo_n "checking qhull/qhull.h presence... " >&6; }
9025 < cat >conftest.$ac_ext <<_ACEOF
9026 < /* confdefs.h.  */
9027 < _ACEOF
9028 < cat confdefs.h >>conftest.$ac_ext
9029 < cat >>conftest.$ac_ext <<_ACEOF
9030 < /* end confdefs.h.  */
9031 < #include <qhull/qhull.h>
9032 < _ACEOF
9033 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9034 < case "(($ac_try" in
9035 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9036 <  *) ac_try_echo=$ac_try;;
9037 < esac
9038 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9039 < $as_echo "$ac_try_echo") >&5
9040 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9041 <  ac_status=$?
9042 <  grep -v '^ *+' conftest.er1 >conftest.err
9043 <  rm -f conftest.er1
9044 <  cat conftest.err >&5
9045 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9046 <  (exit $ac_status); } >/dev/null && {
9047 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
9048 <         test ! -s conftest.err
9049 <       }; then
9050 <  ac_header_preproc=yes
9051 < else
9052 <  $as_echo "$as_me: failed program was:" >&5
9053 < sed 's/^/| /' conftest.$ac_ext >&5
9054 <
9055 <  ac_header_preproc=no
9056 < fi
9057 <
9058 < rm -f conftest.err conftest.$ac_ext
9059 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9060 < $as_echo "$ac_header_preproc" >&6; }
9061 <
9062 < # So?  What about this header?
9063 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9064 <  yes:no: )
9065 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
9066 < $as_echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9067 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
9068 < $as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
9069 <    ac_header_preproc=yes
9070 <    ;;
9071 <  no:yes:* )
9072 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
9073 < $as_echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
9074 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&5
9075 < $as_echo "$as_me: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&2;}
9076 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
9077 < $as_echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
9078 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&5
9079 < $as_echo "$as_me: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9080 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
9081 < $as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
9082 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
9083 < $as_echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
9084 <    ( cat <<\_ASBOX
9085 < ## ------------------------------ ##
9086 < ## Report this to gezelter@nd.edu ##
9087 < ## ------------------------------ ##
9088 < _ASBOX
9089 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9090 <    ;;
9091 < esac
9092 < { $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
9093 < $as_echo_n "checking for qhull/qhull.h... " >&6; }
9094 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
9095 <  $as_echo_n "(cached) " >&6
9096 < else
9097 <  ac_cv_header_qhull_qhull_h=$ac_header_preproc
9098 < fi
9099 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
9100 < $as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
9101 <
9102 < fi
9103 < if test $ac_cv_header_qhull_qhull_h = yes; then
9074 >        ac_fn_c_check_header_mongrel "$LINENO" "qhull/qhull.h" "ac_cv_header_qhull_qhull_h" "$ac_includes_default"
9075 > if test "x$ac_cv_header_qhull_qhull_h" = x""yes; then :
9076    qhull_cv_qhull_h=yes
9077   else
9078    qhull_cv_qhull_h=no
9079   fi
9080  
9081  
9082 <        { $as_echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
9082 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull" >&5
9083   $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
9084 < if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
9084 > if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then :
9085    $as_echo_n "(cached) " >&6
9086   else
9087    ac_check_lib_save_LIBS=$LIBS
9088   LIBS="-lqhull  $LIBS"
9089 < cat >conftest.$ac_ext <<_ACEOF
9118 < /* confdefs.h.  */
9119 < _ACEOF
9120 < cat confdefs.h >>conftest.$ac_ext
9121 < cat >>conftest.$ac_ext <<_ACEOF
9089 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9090   /* end confdefs.h.  */
9091  
9092   /* Override any GCC internal prototype to avoid an error.
# Line 9144 | Line 9112 | _ACEOF
9112    return 0;
9113   }
9114   _ACEOF
9115 < rm -f conftest.$ac_objext conftest$ac_exeext
9148 < if { (ac_try="$ac_link"
9149 < case "(($ac_try" in
9150 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9151 <  *) ac_try_echo=$ac_try;;
9152 < esac
9153 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9154 < $as_echo "$ac_try_echo") >&5
9155 <  (eval "$ac_link") 2>conftest.er1
9156 <  ac_status=$?
9157 <  grep -v '^ *+' conftest.er1 >conftest.err
9158 <  rm -f conftest.er1
9159 <  cat conftest.err >&5
9160 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9161 <  (exit $ac_status); } && {
9162 <         test -z "$ac_c_werror_flag" ||
9163 <         test ! -s conftest.err
9164 <       } && test -s conftest$ac_exeext && {
9165 <         test "$cross_compiling" = yes ||
9166 <         $as_test_x conftest$ac_exeext
9167 <       }; then
9115 > if ac_fn_c_try_link "$LINENO"; then :
9116    ac_cv_lib_qhull_qh_qhull=yes
9117   else
9118 <  $as_echo "$as_me: failed program was:" >&5
9171 < sed 's/^/| /' conftest.$ac_ext >&5
9172 <
9173 <        ac_cv_lib_qhull_qh_qhull=no
9118 >  ac_cv_lib_qhull_qh_qhull=no
9119   fi
9120 <
9121 < rm -rf conftest.dSYM
9177 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9178 <      conftest$ac_exeext conftest.$ac_ext
9120 > rm -f core conftest.err conftest.$ac_objext \
9121 >    conftest$ac_exeext conftest.$ac_ext
9122   LIBS=$ac_check_lib_save_LIBS
9123   fi
9124 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
9124 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull_qh_qhull" >&5
9125   $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
9126 < if test $ac_cv_lib_qhull_qh_qhull = yes; then
9126 > if test "x$ac_cv_lib_qhull_qh_qhull" = x""yes; then :
9127    qhull_cv_libqhull=yes
9128   else
9129    qhull_cv_libqhull=no
# Line 9198 | Line 9141 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
9141  
9142          if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
9143  
9144 < cat >>confdefs.h <<\_ACEOF
9202 < #define HAVE_QHULL_H 1
9203 < _ACEOF
9144 > $as_echo "#define HAVE_QHULL_H 1" >>confdefs.h
9145  
9146  
9147 < cat >>confdefs.h <<\_ACEOF
9207 < #define HAVE_QHULL 1
9208 < _ACEOF
9147 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
9148  
9149 <                USE_QHULL=yes
9150 <                QHULL_INC_DIR="${QHULL_HOME}/include"
9151 <                QHULL_LIB_DIR="${QHULL_HOME}/lib"
9152 <                QHULL="-lqhull"
9149 >           USE_QHULL=yes
9150 >           QHULL_INC_DIR="${QHULL_HOME}/include"
9151 >           QHULL_LIB_DIR="${QHULL_HOME}/lib"
9152 >           QHULL="-lqhull"
9153 >           { $as_echo "$as_me:${as_lineno-$LINENO}: result: Working qhull found, will proceed." >&5
9154 > $as_echo "Working qhull found, will proceed." >&6; }
9155          else
9156 <                { $as_echo "$as_me:$LINENO: checking qhull in ${QHULL_HOME}" >&5
9157 < $as_echo_n "checking qhull in ${QHULL_HOME}... " >&6; }
9158 <                QHULL_INC_DIR=
9159 <                QHULL_LIB_DIR=
9160 <                QHULL=
9161 <                USE_QHULL=no
9162 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
9163 < $as_echo "failed" >&6; }
9164 <                echo ""
9165 <                echo "*********************************************************"
9166 <                echo "* WARNING: Could not find a working qhull installation  *"
9167 <                echo "* If you need OOPSE to be able to deal with convex      *"
9168 <                echo "* hulls be sure to specify a valid qhull installation   *"
9169 <                echo "* with --with-qhull=DIR                                 *"
9170 <                echo "*                                                       *"
9171 <                echo "* OOPSE will still work without qhull installed.        *"
9231 <                echo "*********************************************************"
9232 <                echo ""
9156 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
9157 > $as_echo "$as_me: WARNING: " >&2;}
9158 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
9159 > $as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
9160 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OOPSE to be able to deal with convex    " >&5
9161 > $as_echo "$as_me: WARNING: If you need OOPSE to be able to deal with convex    " >&2;}
9162 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
9163 > $as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
9164 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR                               " >&5
9165 > $as_echo "$as_me: WARNING: with --with-qhull=DIR                               " >&2;}
9166 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
9167 > $as_echo "$as_me: WARNING: " >&2;}
9168 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OOPSE will still work without qhull installed.      " >&5
9169 > $as_echo "$as_me: WARNING: OOPSE will still work without qhull installed.      " >&2;}
9170 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
9171 > $as_echo "$as_me: WARNING: " >&2;}
9172          fi
9173 +    fi
9174 + fi
9175  
9176  
9177  
9178  
9238 – fi
9239 – fi
9179  
9241 –
9180   ac_ext=cpp
9181   ac_cpp='$CXXCPP $CPPFLAGS'
9182   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9183   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9184   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9185 < { $as_echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
9185 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
9186   $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
9187   if test -z "$CXXCPP"; then
9188 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
9188 >  if test "${ac_cv_prog_CXXCPP+set}" = set; then :
9189    $as_echo_n "(cached) " >&6
9190   else
9191        # Double quotes because CXXCPP needs to be expanded
# Line 9262 | Line 9200 | do
9200    # <limits.h> exists even on freestanding compilers.
9201    # On the NeXT, cc -E runs the code through the compiler's parser,
9202    # not just through cpp. "Syntax error" is here to catch this case.
9203 <  cat >conftest.$ac_ext <<_ACEOF
9266 < /* confdefs.h.  */
9267 < _ACEOF
9268 < cat confdefs.h >>conftest.$ac_ext
9269 < cat >>conftest.$ac_ext <<_ACEOF
9203 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9204   /* end confdefs.h.  */
9205   #ifdef __STDC__
9206   # include <limits.h>
# Line 9275 | Line 9209 | _ACEOF
9209   #endif
9210                       Syntax error
9211   _ACEOF
9212 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9279 < case "(($ac_try" in
9280 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9281 <  *) ac_try_echo=$ac_try;;
9282 < esac
9283 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9284 < $as_echo "$ac_try_echo") >&5
9285 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9286 <  ac_status=$?
9287 <  grep -v '^ *+' conftest.er1 >conftest.err
9288 <  rm -f conftest.er1
9289 <  cat conftest.err >&5
9290 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9291 <  (exit $ac_status); } >/dev/null && {
9292 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9293 <         test ! -s conftest.err
9294 <       }; then
9295 <  :
9296 < else
9297 <  $as_echo "$as_me: failed program was:" >&5
9298 < sed 's/^/| /' conftest.$ac_ext >&5
9212 > if ac_fn_cxx_try_cpp "$LINENO"; then :
9213  
9214 + else
9215    # Broken: fails on valid input.
9216   continue
9217   fi
9303 –
9218   rm -f conftest.err conftest.$ac_ext
9219  
9220    # OK, works on sane cases.  Now check whether nonexistent headers
9221    # can be detected and how.
9222 <  cat >conftest.$ac_ext <<_ACEOF
9309 < /* confdefs.h.  */
9310 < _ACEOF
9311 < cat confdefs.h >>conftest.$ac_ext
9312 < cat >>conftest.$ac_ext <<_ACEOF
9222 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9223   /* end confdefs.h.  */
9224   #include <ac_nonexistent.h>
9225   _ACEOF
9226 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9317 < case "(($ac_try" in
9318 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9319 <  *) ac_try_echo=$ac_try;;
9320 < esac
9321 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9322 < $as_echo "$ac_try_echo") >&5
9323 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9324 <  ac_status=$?
9325 <  grep -v '^ *+' conftest.er1 >conftest.err
9326 <  rm -f conftest.er1
9327 <  cat conftest.err >&5
9328 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9329 <  (exit $ac_status); } >/dev/null && {
9330 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9331 <         test ! -s conftest.err
9332 <       }; then
9226 > if ac_fn_cxx_try_cpp "$LINENO"; then :
9227    # Broken: success on invalid input.
9228   continue
9229   else
9336 –  $as_echo "$as_me: failed program was:" >&5
9337 – sed 's/^/| /' conftest.$ac_ext >&5
9338 –
9230    # Passes both tests.
9231   ac_preproc_ok=:
9232   break
9233   fi
9343 –
9234   rm -f conftest.err conftest.$ac_ext
9235  
9236   done
9237   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9238   rm -f conftest.err conftest.$ac_ext
9239 < if $ac_preproc_ok; then
9239 > if $ac_preproc_ok; then :
9240    break
9241   fi
9242  
# Line 9358 | Line 9248 | fi
9248   else
9249    ac_cv_prog_CXXCPP=$CXXCPP
9250   fi
9251 < { $as_echo "$as_me:$LINENO: result: $CXXCPP" >&5
9251 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
9252   $as_echo "$CXXCPP" >&6; }
9253   ac_preproc_ok=false
9254   for ac_cxx_preproc_warn_flag in '' yes
# Line 9369 | Line 9259 | do
9259    # <limits.h> exists even on freestanding compilers.
9260    # On the NeXT, cc -E runs the code through the compiler's parser,
9261    # not just through cpp. "Syntax error" is here to catch this case.
9262 <  cat >conftest.$ac_ext <<_ACEOF
9373 < /* confdefs.h.  */
9374 < _ACEOF
9375 < cat confdefs.h >>conftest.$ac_ext
9376 < cat >>conftest.$ac_ext <<_ACEOF
9262 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9263   /* end confdefs.h.  */
9264   #ifdef __STDC__
9265   # include <limits.h>
# Line 9382 | Line 9268 | _ACEOF
9268   #endif
9269                       Syntax error
9270   _ACEOF
9271 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9386 < case "(($ac_try" in
9387 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9388 <  *) ac_try_echo=$ac_try;;
9389 < esac
9390 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9391 < $as_echo "$ac_try_echo") >&5
9392 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9393 <  ac_status=$?
9394 <  grep -v '^ *+' conftest.er1 >conftest.err
9395 <  rm -f conftest.er1
9396 <  cat conftest.err >&5
9397 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9398 <  (exit $ac_status); } >/dev/null && {
9399 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9400 <         test ! -s conftest.err
9401 <       }; then
9402 <  :
9403 < else
9404 <  $as_echo "$as_me: failed program was:" >&5
9405 < sed 's/^/| /' conftest.$ac_ext >&5
9271 > if ac_fn_cxx_try_cpp "$LINENO"; then :
9272  
9273 + else
9274    # Broken: fails on valid input.
9275   continue
9276   fi
9410 –
9277   rm -f conftest.err conftest.$ac_ext
9278  
9279    # OK, works on sane cases.  Now check whether nonexistent headers
9280    # can be detected and how.
9281 <  cat >conftest.$ac_ext <<_ACEOF
9416 < /* confdefs.h.  */
9417 < _ACEOF
9418 < cat confdefs.h >>conftest.$ac_ext
9419 < cat >>conftest.$ac_ext <<_ACEOF
9281 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9282   /* end confdefs.h.  */
9283   #include <ac_nonexistent.h>
9284   _ACEOF
9285 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9424 < case "(($ac_try" in
9425 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9426 <  *) ac_try_echo=$ac_try;;
9427 < esac
9428 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9429 < $as_echo "$ac_try_echo") >&5
9430 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9431 <  ac_status=$?
9432 <  grep -v '^ *+' conftest.er1 >conftest.err
9433 <  rm -f conftest.er1
9434 <  cat conftest.err >&5
9435 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9436 <  (exit $ac_status); } >/dev/null && {
9437 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9438 <         test ! -s conftest.err
9439 <       }; then
9285 > if ac_fn_cxx_try_cpp "$LINENO"; then :
9286    # Broken: success on invalid input.
9287   continue
9288   else
9443 –  $as_echo "$as_me: failed program was:" >&5
9444 – sed 's/^/| /' conftest.$ac_ext >&5
9445 –
9289    # Passes both tests.
9290   ac_preproc_ok=:
9291   break
9292   fi
9450 –
9293   rm -f conftest.err conftest.$ac_ext
9294  
9295   done
9296   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9297   rm -f conftest.err conftest.$ac_ext
9298 < if $ac_preproc_ok; then
9299 <  :
9298 > if $ac_preproc_ok; then :
9299 >
9300   else
9301 <  { { $as_echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9302 < See \`config.log' for more details." >&5
9303 < $as_echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9304 < See \`config.log' for more details." >&2;}
9463 <   { (exit 1); exit 1; }; }
9301 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
9302 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
9303 > as_fn_error "C++ preprocessor \"$CXXCPP\" fails sanity check
9304 > See \`config.log' for more details." "$LINENO" 5; }
9305   fi
9306  
9307   ac_ext=cpp
# Line 9475 | Line 9316 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9316   #
9317  
9318   # Check whether --with-openbabel was given.
9319 < if test "${with_openbabel+set}" = set; then
9319 > if test "${with_openbabel+set}" = set; then :
9320    withval=$with_openbabel; openbabel_dir="$withval"
9321   else
9322                  openbabel_dir="not_set"
# Line 9488 | Line 9329 | if test "$openbabel_dir" != "not_set" ; then
9329    then
9330      OPENBABEL_HOME="$openbabel_dir"
9331    else
9332 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
9332 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
9333   $as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
9334          OPENBABEL_HOME=/usr/local
9335          if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
# Line 9498 | Line 9339 | fi
9339    fi
9340   fi
9341   #
9342 < # Locate openbabel, if wanted
9343 < #
9344 < if test -n "${OPENBABEL_HOME}"
9345 < then
9505 <
9506 <        ac_ext=cpp
9507 < ac_cpp='$CXXCPP $CPPFLAGS'
9508 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9509 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9510 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9511 <
9512 <        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
9513 <        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
9514 <        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
9515 <        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
9516 <        if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9517 <  { $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9518 < $as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9519 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9520 <  $as_echo_n "(cached) " >&6
9521 < fi
9522 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9523 < $as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9524 < else
9525 <  # Is the header compilable?
9526 < { $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h usability" >&5
9527 < $as_echo_n "checking openbabel/babelconfig.h usability... " >&6; }
9528 < cat >conftest.$ac_ext <<_ACEOF
9529 < /* confdefs.h.  */
9530 < _ACEOF
9531 < cat confdefs.h >>conftest.$ac_ext
9532 < cat >>conftest.$ac_ext <<_ACEOF
9533 < /* end confdefs.h.  */
9534 < $ac_includes_default
9535 < #include <openbabel/babelconfig.h>
9536 < _ACEOF
9537 < rm -f conftest.$ac_objext
9538 < if { (ac_try="$ac_compile"
9539 < case "(($ac_try" in
9540 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9541 <  *) ac_try_echo=$ac_try;;
9542 < esac
9543 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9544 < $as_echo "$ac_try_echo") >&5
9545 <  (eval "$ac_compile") 2>conftest.er1
9546 <  ac_status=$?
9547 <  grep -v '^ *+' conftest.er1 >conftest.err
9548 <  rm -f conftest.er1
9549 <  cat conftest.err >&5
9550 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9551 <  (exit $ac_status); } && {
9552 <         test -z "$ac_cxx_werror_flag" ||
9553 <         test ! -s conftest.err
9554 <       } && test -s conftest.$ac_objext; then
9555 <  ac_header_compiler=yes
9556 < else
9557 <  $as_echo "$as_me: failed program was:" >&5
9558 < sed 's/^/| /' conftest.$ac_ext >&5
9559 <
9560 <        ac_header_compiler=no
9561 < fi
9562 <
9563 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9564 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9565 < $as_echo "$ac_header_compiler" >&6; }
9566 <
9567 < # Is the header present?
9568 < { $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h presence" >&5
9569 < $as_echo_n "checking openbabel/babelconfig.h presence... " >&6; }
9570 < cat >conftest.$ac_ext <<_ACEOF
9571 < /* confdefs.h.  */
9572 < _ACEOF
9573 < cat confdefs.h >>conftest.$ac_ext
9574 < cat >>conftest.$ac_ext <<_ACEOF
9575 < /* end confdefs.h.  */
9576 < #include <openbabel/babelconfig.h>
9577 < _ACEOF
9578 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9579 < case "(($ac_try" in
9580 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9581 <  *) ac_try_echo=$ac_try;;
9582 < esac
9583 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9584 < $as_echo "$ac_try_echo") >&5
9585 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9586 <  ac_status=$?
9587 <  grep -v '^ *+' conftest.er1 >conftest.err
9588 <  rm -f conftest.er1
9589 <  cat conftest.err >&5
9590 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9591 <  (exit $ac_status); } >/dev/null && {
9592 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9593 <         test ! -s conftest.err
9594 <       }; then
9595 <  ac_header_preproc=yes
9596 < else
9597 <  $as_echo "$as_me: failed program was:" >&5
9598 < sed 's/^/| /' conftest.$ac_ext >&5
9599 <
9600 <  ac_header_preproc=no
9601 < fi
9602 <
9603 < rm -f conftest.err conftest.$ac_ext
9604 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9605 < $as_echo "$ac_header_preproc" >&6; }
9606 <
9607 < # So?  What about this header?
9608 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9609 <  yes:no: )
9610 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5
9611 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9612 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&5
9613 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&2;}
9614 <    ac_header_preproc=yes
9615 <    ;;
9616 <  no:yes:* )
9617 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&5
9618 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&2;}
9619 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&5
9620 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&2;}
9621 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&5
9622 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&2;}
9623 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&5
9624 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9625 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&5
9626 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&2;}
9627 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&5
9628 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&2;}
9629 <    ( cat <<\_ASBOX
9630 < ## ------------------------------ ##
9631 < ## Report this to gezelter@nd.edu ##
9632 < ## ------------------------------ ##
9633 < _ASBOX
9634 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9635 <    ;;
9636 < esac
9637 < { $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9638 < $as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9639 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9640 <  $as_echo_n "(cached) " >&6
9641 < else
9642 <  ac_cv_header_openbabel_babelconfig_h=$ac_header_preproc
9643 < fi
9644 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9645 < $as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9342 > # Locate openbabel, if wanted
9343 > #
9344 > if test -n "${OPENBABEL_HOME}"
9345 > then
9346  
9347 < fi
9348 < if test $ac_cv_header_openbabel_babelconfig_h = yes; then
9347 >        ac_ext=cpp
9348 > ac_cpp='$CXXCPP $CPPFLAGS'
9349 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9350 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9351 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9352 >
9353 >        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
9354 >        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
9355 >        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
9356 >        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
9357 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/babelconfig.h" "ac_cv_header_openbabel_babelconfig_h" "$ac_includes_default"
9358 > if test "x$ac_cv_header_openbabel_babelconfig_h" = x""yes; then :
9359    openbabel_cv_openbabel_h=yes
9360   else
9361    openbabel_cv_openbabel_h=no
9362   fi
9363  
9364  
9365 <        if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9366 <  { $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9657 < $as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9658 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9659 <  $as_echo_n "(cached) " >&6
9660 < fi
9661 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9662 < $as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9663 < else
9664 <  # Is the header compilable?
9665 < { $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h usability" >&5
9666 < $as_echo_n "checking openbabel/obconversion.h usability... " >&6; }
9667 < cat >conftest.$ac_ext <<_ACEOF
9668 < /* confdefs.h.  */
9669 < _ACEOF
9670 < cat confdefs.h >>conftest.$ac_ext
9671 < cat >>conftest.$ac_ext <<_ACEOF
9672 < /* end confdefs.h.  */
9673 < $ac_includes_default
9674 < #include <openbabel/obconversion.h>
9675 < _ACEOF
9676 < rm -f conftest.$ac_objext
9677 < if { (ac_try="$ac_compile"
9678 < case "(($ac_try" in
9679 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9680 <  *) ac_try_echo=$ac_try;;
9681 < esac
9682 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9683 < $as_echo "$ac_try_echo") >&5
9684 <  (eval "$ac_compile") 2>conftest.er1
9685 <  ac_status=$?
9686 <  grep -v '^ *+' conftest.er1 >conftest.err
9687 <  rm -f conftest.er1
9688 <  cat conftest.err >&5
9689 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9690 <  (exit $ac_status); } && {
9691 <         test -z "$ac_cxx_werror_flag" ||
9692 <         test ! -s conftest.err
9693 <       } && test -s conftest.$ac_objext; then
9694 <  ac_header_compiler=yes
9695 < else
9696 <  $as_echo "$as_me: failed program was:" >&5
9697 < sed 's/^/| /' conftest.$ac_ext >&5
9698 <
9699 <        ac_header_compiler=no
9700 < fi
9701 <
9702 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9703 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9704 < $as_echo "$ac_header_compiler" >&6; }
9705 <
9706 < # Is the header present?
9707 < { $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h presence" >&5
9708 < $as_echo_n "checking openbabel/obconversion.h presence... " >&6; }
9709 < cat >conftest.$ac_ext <<_ACEOF
9710 < /* confdefs.h.  */
9711 < _ACEOF
9712 < cat confdefs.h >>conftest.$ac_ext
9713 < cat >>conftest.$ac_ext <<_ACEOF
9714 < /* end confdefs.h.  */
9715 < #include <openbabel/obconversion.h>
9716 < _ACEOF
9717 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9718 < case "(($ac_try" in
9719 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9720 <  *) ac_try_echo=$ac_try;;
9721 < esac
9722 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9723 < $as_echo "$ac_try_echo") >&5
9724 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9725 <  ac_status=$?
9726 <  grep -v '^ *+' conftest.er1 >conftest.err
9727 <  rm -f conftest.er1
9728 <  cat conftest.err >&5
9729 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9730 <  (exit $ac_status); } >/dev/null && {
9731 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9732 <         test ! -s conftest.err
9733 <       }; then
9734 <  ac_header_preproc=yes
9735 < else
9736 <  $as_echo "$as_me: failed program was:" >&5
9737 < sed 's/^/| /' conftest.$ac_ext >&5
9738 <
9739 <  ac_header_preproc=no
9740 < fi
9741 <
9742 < rm -f conftest.err conftest.$ac_ext
9743 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9744 < $as_echo "$ac_header_preproc" >&6; }
9745 <
9746 < # So?  What about this header?
9747 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9748 <  yes:no: )
9749 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&5
9750 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9751 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&5
9752 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&2;}
9753 <    ac_header_preproc=yes
9754 <    ;;
9755 <  no:yes:* )
9756 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&5
9757 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&2;}
9758 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&5
9759 < $as_echo "$as_me: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&2;}
9760 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&5
9761 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&2;}
9762 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&5
9763 < $as_echo "$as_me: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9764 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&5
9765 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&2;}
9766 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&5
9767 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&2;}
9768 <    ( cat <<\_ASBOX
9769 < ## ------------------------------ ##
9770 < ## Report this to gezelter@nd.edu ##
9771 < ## ------------------------------ ##
9772 < _ASBOX
9773 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9774 <    ;;
9775 < esac
9776 < { $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9777 < $as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9778 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9779 <  $as_echo_n "(cached) " >&6
9780 < else
9781 <  ac_cv_header_openbabel_obconversion_h=$ac_header_preproc
9782 < fi
9783 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9784 < $as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9785 <
9786 < fi
9787 < if test $ac_cv_header_openbabel_obconversion_h = yes; then
9365 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/obconversion.h" "ac_cv_header_openbabel_obconversion_h" "$ac_includes_default"
9366 > if test "x$ac_cv_header_openbabel_obconversion_h" = x""yes; then :
9367    openbabel_cv_obconversion_h=yes
9368   else
9369    openbabel_cv_obconversion_h=no
9370   fi
9371  
9372  
9373 <        cat >conftest.$ac_ext <<_ACEOF
9795 <
9796 <             /* confdefs.h.  */
9797 < _ACEOF
9798 < cat confdefs.h >>conftest.$ac_ext
9799 < cat >>conftest.$ac_ext <<_ACEOF
9373 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9374   /* end confdefs.h.  */
9375  
9376 +
9377   #include <openbabel/babelconfig.h>
9378   #include <openbabel/obconversion.h>
9379   using namespace std;
# Line 9823 | Line 9398 | _ACEOF
9398    return 0;
9399   }
9400   _ACEOF
9401 < rm -f conftest.$ac_objext conftest$ac_exeext
9827 < if { (ac_try="$ac_link"
9828 < case "(($ac_try" in
9829 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9830 <  *) ac_try_echo=$ac_try;;
9831 < esac
9832 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9833 < $as_echo "$ac_try_echo") >&5
9834 <  (eval "$ac_link") 2>conftest.er1
9835 <  ac_status=$?
9836 <  grep -v '^ *+' conftest.er1 >conftest.err
9837 <  rm -f conftest.er1
9838 <  cat conftest.err >&5
9839 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9840 <  (exit $ac_status); } && {
9841 <         test -z "$ac_cxx_werror_flag" ||
9842 <         test ! -s conftest.err
9843 <       } && test -s conftest$ac_exeext && {
9844 <         test "$cross_compiling" = yes ||
9845 <         $as_test_x conftest$ac_exeext
9846 <       }; then
9401 > if ac_fn_cxx_try_link "$LINENO"; then :
9402  
9403                  openbabel_lib_found="yes"
9404 <                { $as_echo "$as_me:$LINENO: result: found" >&5
9404 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
9405   $as_echo "found" >&6; }
9406  
9407   else
9853 –  $as_echo "$as_me: failed program was:" >&5
9854 – sed 's/^/| /' conftest.$ac_ext >&5
9408  
9856 –
9409                  openbabel_lib_found="no"
9410 <                { $as_echo "$as_me:$LINENO: result: not found" >&5
9410 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
9411   $as_echo "not found" >&6; }
9412  
9413  
9414   fi
9415 <
9416 < rm -rf conftest.dSYM
9865 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9866 <      conftest$ac_exeext conftest.$ac_ext
9415 > rm -f core conftest.err conftest.$ac_objext \
9416 >    conftest$ac_exeext conftest.$ac_ext
9417          ac_ext=c
9418   ac_cpp='$CPP $CPPFLAGS'
9419   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 9879 | Line 9429 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
9429                  OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
9430                  OPENBABEL_LIB="-lopenbabel"
9431          else
9432 <                { $as_echo "$as_me:$LINENO: checking openbabel in ${OPENBABEL_HOME}" >&5
9432 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking openbabel in ${OPENBABEL_HOME}" >&5
9433   $as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
9434                  OPENBABEL_INC_DIR=
9435                  OPENBABEL_LIB_DIR=
9436                  OPENBABEL_LIB=
9437                  USE_OPENBABEL=no
9438 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
9438 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
9439   $as_echo "failed" >&6; }
9440                  echo ""
9441                  echo "*********************************************************"
# Line 9907 | Line 9457 | fi
9457  
9458  
9459   # Checks for header files.
9460 < { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
9460 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
9461   $as_echo_n "checking for ANSI C header files... " >&6; }
9462 < if test "${ac_cv_header_stdc+set}" = set; then
9462 > if test "${ac_cv_header_stdc+set}" = set; then :
9463    $as_echo_n "(cached) " >&6
9464   else
9465 <  cat >conftest.$ac_ext <<_ACEOF
9916 < /* confdefs.h.  */
9917 < _ACEOF
9918 < cat confdefs.h >>conftest.$ac_ext
9919 < cat >>conftest.$ac_ext <<_ACEOF
9465 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9466   /* end confdefs.h.  */
9467   #include <stdlib.h>
9468   #include <stdarg.h>
# Line 9939 | Line 9485 | _ACEOF
9485    return 0;
9486   }
9487   _ACEOF
9488 < rm -f conftest.$ac_objext
9943 < if { (ac_try="$ac_compile"
9944 < case "(($ac_try" in
9945 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9946 <  *) ac_try_echo=$ac_try;;
9947 < esac
9948 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9949 < $as_echo "$ac_try_echo") >&5
9950 <  (eval "$ac_compile") 2>conftest.er1
9951 <  ac_status=$?
9952 <  grep -v '^ *+' conftest.er1 >conftest.err
9953 <  rm -f conftest.er1
9954 <  cat conftest.err >&5
9955 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9956 <  (exit $ac_status); } && {
9957 <         test -z "$ac_c_werror_flag" ||
9958 <         test ! -s conftest.err
9959 <       } && test -s conftest.$ac_objext; then
9488 > if ac_fn_c_try_compile "$LINENO"; then :
9489    ac_cv_header_stdc=yes
9490   else
9491 <  $as_echo "$as_me: failed program was:" >&5
9963 < sed 's/^/| /' conftest.$ac_ext >&5
9964 <
9965 <        ac_cv_header_stdc=no
9491 >  ac_cv_header_stdc=no
9492   fi
9967 –
9493   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9494  
9495   if test $ac_cv_header_stdc = yes; then
9496    # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
9497 <  cat >conftest.$ac_ext <<_ACEOF
9973 < /* confdefs.h.  */
9974 < _ACEOF
9975 < cat confdefs.h >>conftest.$ac_ext
9976 < cat >>conftest.$ac_ext <<_ACEOF
9497 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9498   /* end confdefs.h.  */
9499   #include <string.h>
9500  
9501   _ACEOF
9502   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
9503 <  $EGREP "memchr" >/dev/null 2>&1; then
9504 <  :
9503 >  $EGREP "memchr" >/dev/null 2>&1; then :
9504 >
9505   else
9506    ac_cv_header_stdc=no
9507   fi
# Line 9990 | Line 9511 | if test $ac_cv_header_stdc = yes; then
9511  
9512   if test $ac_cv_header_stdc = yes; then
9513    # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
9514 <  cat >conftest.$ac_ext <<_ACEOF
9994 < /* confdefs.h.  */
9995 < _ACEOF
9996 < cat confdefs.h >>conftest.$ac_ext
9997 < cat >>conftest.$ac_ext <<_ACEOF
9514 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9515   /* end confdefs.h.  */
9516   #include <stdlib.h>
9517  
9518   _ACEOF
9519   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
9520 <  $EGREP "free" >/dev/null 2>&1; then
9521 <  :
9520 >  $EGREP "free" >/dev/null 2>&1; then :
9521 >
9522   else
9523    ac_cv_header_stdc=no
9524   fi
# Line 10011 | Line 9528 | if test $ac_cv_header_stdc = yes; then
9528  
9529   if test $ac_cv_header_stdc = yes; then
9530    # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
9531 <  if test "$cross_compiling" = yes; then
9531 >  if test "$cross_compiling" = yes; then :
9532    :
9533   else
9534 <  cat >conftest.$ac_ext <<_ACEOF
10018 < /* confdefs.h.  */
10019 < _ACEOF
10020 < cat confdefs.h >>conftest.$ac_ext
10021 < cat >>conftest.$ac_ext <<_ACEOF
9534 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9535   /* end confdefs.h.  */
9536   #include <ctype.h>
9537   #include <stdlib.h>
# Line 10045 | Line 9558 | _ACEOF
9558    return 0;
9559   }
9560   _ACEOF
9561 < rm -f conftest$ac_exeext
10049 < if { (ac_try="$ac_link"
10050 < case "(($ac_try" in
10051 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10052 <  *) ac_try_echo=$ac_try;;
10053 < esac
10054 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10055 < $as_echo "$ac_try_echo") >&5
10056 <  (eval "$ac_link") 2>&5
10057 <  ac_status=$?
10058 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10059 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10060 <  { (case "(($ac_try" in
10061 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10062 <  *) ac_try_echo=$ac_try;;
10063 < esac
10064 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10065 < $as_echo "$ac_try_echo") >&5
10066 <  (eval "$ac_try") 2>&5
10067 <  ac_status=$?
10068 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10069 <  (exit $ac_status); }; }; then
10070 <  :
10071 < else
10072 <  $as_echo "$as_me: program exited with status $ac_status" >&5
10073 < $as_echo "$as_me: failed program was:" >&5
10074 < sed 's/^/| /' conftest.$ac_ext >&5
9561 > if ac_fn_c_try_run "$LINENO"; then :
9562  
9563 < ( exit $ac_status )
9564 < ac_cv_header_stdc=no
9563 > else
9564 >  ac_cv_header_stdc=no
9565   fi
9566 < rm -rf conftest.dSYM
9567 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9566 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
9567 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
9568   fi
9569  
10083 –
9570   fi
9571   fi
9572 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
9572 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
9573   $as_echo "$ac_cv_header_stdc" >&6; }
9574   if test $ac_cv_header_stdc = yes; then
9575  
9576 < cat >>confdefs.h <<\_ACEOF
10091 < #define STDC_HEADERS 1
10092 < _ACEOF
9576 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
9577  
9578   fi
9579  
10096 –
10097 –
10098 –
10099 –
10100 –
10101 –
10102 –
10103 –
10104 –
10105 –
10106 –
10107 –
10108 –
10109 –
10110 –
9580   for ac_header in libintl.h limits.h machine/hal_sysinfo.h stdlib.h string.h strings.h sys/param.h sys/pstat.h sys/sysctl.h sys/sysinfo.h sys/sysmp.h sys/systemcfg.h sys/table.h sys/time.h unistd.h
9581 < do
9582 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
9583 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9584 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
9585 < $as_echo_n "checking for $ac_header... " >&6; }
10117 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10118 <  $as_echo_n "(cached) " >&6
10119 < fi
10120 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10121 <                 $as_echo "$as_val"'`
10122 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10123 < $as_echo "$ac_res" >&6; }
10124 < else
10125 <  # Is the header compilable?
10126 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10127 < $as_echo_n "checking $ac_header usability... " >&6; }
10128 < cat >conftest.$ac_ext <<_ACEOF
10129 < /* confdefs.h.  */
10130 < _ACEOF
10131 < cat confdefs.h >>conftest.$ac_ext
10132 < cat >>conftest.$ac_ext <<_ACEOF
10133 < /* end confdefs.h.  */
10134 < $ac_includes_default
10135 < #include <$ac_header>
10136 < _ACEOF
10137 < rm -f conftest.$ac_objext
10138 < if { (ac_try="$ac_compile"
10139 < case "(($ac_try" in
10140 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10141 <  *) ac_try_echo=$ac_try;;
10142 < esac
10143 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10144 < $as_echo "$ac_try_echo") >&5
10145 <  (eval "$ac_compile") 2>conftest.er1
10146 <  ac_status=$?
10147 <  grep -v '^ *+' conftest.er1 >conftest.err
10148 <  rm -f conftest.er1
10149 <  cat conftest.err >&5
10150 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10151 <  (exit $ac_status); } && {
10152 <         test -z "$ac_c_werror_flag" ||
10153 <         test ! -s conftest.err
10154 <       } && test -s conftest.$ac_objext; then
10155 <  ac_header_compiler=yes
10156 < else
10157 <  $as_echo "$as_me: failed program was:" >&5
10158 < sed 's/^/| /' conftest.$ac_ext >&5
10159 <
10160 <        ac_header_compiler=no
10161 < fi
10162 <
10163 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10164 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10165 < $as_echo "$ac_header_compiler" >&6; }
10166 <
10167 < # Is the header present?
10168 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10169 < $as_echo_n "checking $ac_header presence... " >&6; }
10170 < cat >conftest.$ac_ext <<_ACEOF
10171 < /* confdefs.h.  */
10172 < _ACEOF
10173 < cat confdefs.h >>conftest.$ac_ext
10174 < cat >>conftest.$ac_ext <<_ACEOF
10175 < /* end confdefs.h.  */
10176 < #include <$ac_header>
10177 < _ACEOF
10178 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10179 < case "(($ac_try" in
10180 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10181 <  *) ac_try_echo=$ac_try;;
10182 < esac
10183 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10184 < $as_echo "$ac_try_echo") >&5
10185 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10186 <  ac_status=$?
10187 <  grep -v '^ *+' conftest.er1 >conftest.err
10188 <  rm -f conftest.er1
10189 <  cat conftest.err >&5
10190 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10191 <  (exit $ac_status); } >/dev/null && {
10192 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10193 <         test ! -s conftest.err
10194 <       }; then
10195 <  ac_header_preproc=yes
10196 < else
10197 <  $as_echo "$as_me: failed program was:" >&5
10198 < sed 's/^/| /' conftest.$ac_ext >&5
10199 <
10200 <  ac_header_preproc=no
10201 < fi
10202 <
10203 < rm -f conftest.err conftest.$ac_ext
10204 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10205 < $as_echo "$ac_header_preproc" >&6; }
10206 <
10207 < # So?  What about this header?
10208 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10209 <  yes:no: )
10210 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10211 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10212 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10213 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10214 <    ac_header_preproc=yes
10215 <    ;;
10216 <  no:yes:* )
10217 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10218 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10219 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10220 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10221 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10222 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10223 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10224 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10225 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10226 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10227 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10228 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10229 <    ( cat <<\_ASBOX
10230 < ## ------------------------------ ##
10231 < ## Report this to gezelter@nd.edu ##
10232 < ## ------------------------------ ##
10233 < _ASBOX
10234 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10235 <    ;;
10236 < esac
10237 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10238 < $as_echo_n "checking for $ac_header... " >&6; }
10239 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10240 <  $as_echo_n "(cached) " >&6
10241 < else
10242 <  eval "$as_ac_Header=\$ac_header_preproc"
10243 < fi
10244 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10245 <                 $as_echo "$as_val"'`
10246 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10247 < $as_echo "$ac_res" >&6; }
10248 <
10249 < fi
10250 < if test `eval 'as_val=${'$as_ac_Header'}
10251 <                 $as_echo "$as_val"'` = yes; then
9581 > do :
9582 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
9583 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
9584 > eval as_val=\$$as_ac_Header
9585 >   if test "x$as_val" = x""yes; then :
9586    cat >>confdefs.h <<_ACEOF
9587   #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
9588   _ACEOF
# Line 10259 | Line 9593 | done
9593  
9594  
9595   # Checks for typedefs, structures, and compiler characteristics.
9596 < { $as_echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
9596 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
9597   $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
9598 < if test "${ac_cv_header_stdbool_h+set}" = set; then
9598 > if test "${ac_cv_header_stdbool_h+set}" = set; then :
9599    $as_echo_n "(cached) " >&6
9600   else
9601 <  cat >conftest.$ac_ext <<_ACEOF
10268 < /* confdefs.h.  */
10269 < _ACEOF
10270 < cat confdefs.h >>conftest.$ac_ext
10271 < cat >>conftest.$ac_ext <<_ACEOF
9601 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9602   /* end confdefs.h.  */
9603  
9604   #include <stdbool.h>
# Line 10356 | Line 9686 | _ACEOF
9686    return 0;
9687   }
9688   _ACEOF
9689 < rm -f conftest.$ac_objext
10360 < if { (ac_try="$ac_compile"
10361 < case "(($ac_try" in
10362 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10363 <  *) ac_try_echo=$ac_try;;
10364 < esac
10365 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10366 < $as_echo "$ac_try_echo") >&5
10367 <  (eval "$ac_compile") 2>conftest.er1
10368 <  ac_status=$?
10369 <  grep -v '^ *+' conftest.er1 >conftest.err
10370 <  rm -f conftest.er1
10371 <  cat conftest.err >&5
10372 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10373 <  (exit $ac_status); } && {
10374 <         test -z "$ac_c_werror_flag" ||
10375 <         test ! -s conftest.err
10376 <       } && test -s conftest.$ac_objext; then
9689 > if ac_fn_c_try_compile "$LINENO"; then :
9690    ac_cv_header_stdbool_h=yes
9691   else
9692 <  $as_echo "$as_me: failed program was:" >&5
10380 < sed 's/^/| /' conftest.$ac_ext >&5
10381 <
10382 <        ac_cv_header_stdbool_h=no
9692 >  ac_cv_header_stdbool_h=no
9693   fi
10384 –
9694   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9695   fi
9696 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
9696 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
9697   $as_echo "$ac_cv_header_stdbool_h" >&6; }
9698 < { $as_echo "$as_me:$LINENO: checking for _Bool" >&5
9699 < $as_echo_n "checking for _Bool... " >&6; }
10391 < if test "${ac_cv_type__Bool+set}" = set; then
10392 <  $as_echo_n "(cached) " >&6
10393 < else
10394 <  ac_cv_type__Bool=no
10395 < cat >conftest.$ac_ext <<_ACEOF
10396 < /* confdefs.h.  */
10397 < _ACEOF
10398 < cat confdefs.h >>conftest.$ac_ext
10399 < cat >>conftest.$ac_ext <<_ACEOF
10400 < /* end confdefs.h.  */
10401 < $ac_includes_default
10402 < #ifdef FC_DUMMY_MAIN
10403 < #ifndef FC_DUMMY_MAIN_EQ_F77
10404 < #  ifdef __cplusplus
10405 <     extern "C"
10406 < #  endif
10407 <   int FC_DUMMY_MAIN() { return 1; }
10408 < #endif
10409 < #endif
10410 < int
10411 < main ()
10412 < {
10413 < if (sizeof (_Bool))
10414 <       return 0;
10415 <  ;
10416 <  return 0;
10417 < }
10418 < _ACEOF
10419 < rm -f conftest.$ac_objext
10420 < if { (ac_try="$ac_compile"
10421 < case "(($ac_try" in
10422 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10423 <  *) ac_try_echo=$ac_try;;
10424 < esac
10425 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10426 < $as_echo "$ac_try_echo") >&5
10427 <  (eval "$ac_compile") 2>conftest.er1
10428 <  ac_status=$?
10429 <  grep -v '^ *+' conftest.er1 >conftest.err
10430 <  rm -f conftest.er1
10431 <  cat conftest.err >&5
10432 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10433 <  (exit $ac_status); } && {
10434 <         test -z "$ac_c_werror_flag" ||
10435 <         test ! -s conftest.err
10436 <       } && test -s conftest.$ac_objext; then
10437 <  cat >conftest.$ac_ext <<_ACEOF
10438 < /* confdefs.h.  */
10439 < _ACEOF
10440 < cat confdefs.h >>conftest.$ac_ext
10441 < cat >>conftest.$ac_ext <<_ACEOF
10442 < /* end confdefs.h.  */
10443 < $ac_includes_default
10444 < #ifdef FC_DUMMY_MAIN
10445 < #ifndef FC_DUMMY_MAIN_EQ_F77
10446 < #  ifdef __cplusplus
10447 <     extern "C"
10448 < #  endif
10449 <   int FC_DUMMY_MAIN() { return 1; }
10450 < #endif
10451 < #endif
10452 < int
10453 < main ()
10454 < {
10455 < if (sizeof ((_Bool)))
10456 <          return 0;
10457 <  ;
10458 <  return 0;
10459 < }
10460 < _ACEOF
10461 < rm -f conftest.$ac_objext
10462 < if { (ac_try="$ac_compile"
10463 < case "(($ac_try" in
10464 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10465 <  *) ac_try_echo=$ac_try;;
10466 < esac
10467 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10468 < $as_echo "$ac_try_echo") >&5
10469 <  (eval "$ac_compile") 2>conftest.er1
10470 <  ac_status=$?
10471 <  grep -v '^ *+' conftest.er1 >conftest.err
10472 <  rm -f conftest.er1
10473 <  cat conftest.err >&5
10474 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10475 <  (exit $ac_status); } && {
10476 <         test -z "$ac_c_werror_flag" ||
10477 <         test ! -s conftest.err
10478 <       } && test -s conftest.$ac_objext; then
10479 <  :
10480 < else
10481 <  $as_echo "$as_me: failed program was:" >&5
10482 < sed 's/^/| /' conftest.$ac_ext >&5
9698 > ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
9699 > if test "x$ac_cv_type__Bool" = x""yes; then :
9700  
10484 –        ac_cv_type__Bool=yes
10485 – fi
10486 –
10487 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10488 – else
10489 –  $as_echo "$as_me: failed program was:" >&5
10490 – sed 's/^/| /' conftest.$ac_ext >&5
10491 –
10492 –
10493 – fi
10494 –
10495 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10496 – fi
10497 – { $as_echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
10498 – $as_echo "$ac_cv_type__Bool" >&6; }
10499 – if test $ac_cv_type__Bool = yes; then
10500 –
9701   cat >>confdefs.h <<_ACEOF
9702   #define HAVE__BOOL 1
9703   _ACEOF
# Line 10507 | Line 9707 | if test $ac_cv_header_stdbool_h = yes; then
9707  
9708   if test $ac_cv_header_stdbool_h = yes; then
9709  
9710 < cat >>confdefs.h <<\_ACEOF
10511 < #define HAVE_STDBOOL_H 1
10512 < _ACEOF
9710 > $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
9711  
9712   fi
9713  
9714 < { $as_echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
9714 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
9715   $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
9716 < if test "${ac_cv_c_const+set}" = set; then
9716 > if test "${ac_cv_c_const+set}" = set; then :
9717    $as_echo_n "(cached) " >&6
9718   else
9719 <  cat >conftest.$ac_ext <<_ACEOF
10522 < /* confdefs.h.  */
10523 < _ACEOF
10524 < cat confdefs.h >>conftest.$ac_ext
10525 < cat >>conftest.$ac_ext <<_ACEOF
9719 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9720   /* end confdefs.h.  */
9721  
9722   #ifdef FC_DUMMY_MAIN
# Line 10590 | Line 9784 | _ACEOF
9784    return 0;
9785   }
9786   _ACEOF
9787 < rm -f conftest.$ac_objext
10594 < if { (ac_try="$ac_compile"
10595 < case "(($ac_try" in
10596 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10597 <  *) ac_try_echo=$ac_try;;
10598 < esac
10599 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10600 < $as_echo "$ac_try_echo") >&5
10601 <  (eval "$ac_compile") 2>conftest.er1
10602 <  ac_status=$?
10603 <  grep -v '^ *+' conftest.er1 >conftest.err
10604 <  rm -f conftest.er1
10605 <  cat conftest.err >&5
10606 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10607 <  (exit $ac_status); } && {
10608 <         test -z "$ac_c_werror_flag" ||
10609 <         test ! -s conftest.err
10610 <       } && test -s conftest.$ac_objext; then
9787 > if ac_fn_c_try_compile "$LINENO"; then :
9788    ac_cv_c_const=yes
9789   else
9790 <  $as_echo "$as_me: failed program was:" >&5
10614 < sed 's/^/| /' conftest.$ac_ext >&5
10615 <
10616 <        ac_cv_c_const=no
9790 >  ac_cv_c_const=no
9791   fi
10618 –
9792   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9793   fi
9794 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
9794 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
9795   $as_echo "$ac_cv_c_const" >&6; }
9796   if test $ac_cv_c_const = no; then
9797  
9798 < cat >>confdefs.h <<\_ACEOF
10626 < #define const /**/
10627 < _ACEOF
9798 > $as_echo "#define const /**/" >>confdefs.h
9799  
9800   fi
9801  
9802 < { $as_echo "$as_me:$LINENO: checking for inline" >&5
9802 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
9803   $as_echo_n "checking for inline... " >&6; }
9804 < if test "${ac_cv_c_inline+set}" = set; then
9804 > if test "${ac_cv_c_inline+set}" = set; then :
9805    $as_echo_n "(cached) " >&6
9806   else
9807    ac_cv_c_inline=no
9808   for ac_kw in inline __inline__ __inline; do
9809 <  cat >conftest.$ac_ext <<_ACEOF
10639 < /* confdefs.h.  */
10640 < _ACEOF
10641 < cat confdefs.h >>conftest.$ac_ext
10642 < cat >>conftest.$ac_ext <<_ACEOF
9809 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9810   /* end confdefs.h.  */
9811   #ifndef __cplusplus
9812   typedef int foo_t;
# Line 10648 | Line 9815 | _ACEOF
9815   #endif
9816  
9817   _ACEOF
9818 < rm -f conftest.$ac_objext
10652 < if { (ac_try="$ac_compile"
10653 < case "(($ac_try" in
10654 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10655 <  *) ac_try_echo=$ac_try;;
10656 < esac
10657 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10658 < $as_echo "$ac_try_echo") >&5
10659 <  (eval "$ac_compile") 2>conftest.er1
10660 <  ac_status=$?
10661 <  grep -v '^ *+' conftest.er1 >conftest.err
10662 <  rm -f conftest.er1
10663 <  cat conftest.err >&5
10664 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10665 <  (exit $ac_status); } && {
10666 <         test -z "$ac_c_werror_flag" ||
10667 <         test ! -s conftest.err
10668 <       } && test -s conftest.$ac_objext; then
9818 > if ac_fn_c_try_compile "$LINENO"; then :
9819    ac_cv_c_inline=$ac_kw
10670 – else
10671 –  $as_echo "$as_me: failed program was:" >&5
10672 – sed 's/^/| /' conftest.$ac_ext >&5
10673 –
10674 –
9820   fi
10676 –
9821   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9822    test "$ac_cv_c_inline" != no && break
9823   done
9824  
9825   fi
9826 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
9826 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
9827   $as_echo "$ac_cv_c_inline" >&6; }
9828  
10685 –
9829   case $ac_cv_c_inline in
9830    inline | yes) ;;
9831    *)
# Line 10698 | Line 9841 | esac
9841      ;;
9842   esac
9843  
9844 < { $as_echo "$as_me:$LINENO: checking for size_t" >&5
9845 < $as_echo_n "checking for size_t... " >&6; }
10703 < if test "${ac_cv_type_size_t+set}" = set; then
10704 <  $as_echo_n "(cached) " >&6
10705 < else
10706 <  ac_cv_type_size_t=no
10707 < cat >conftest.$ac_ext <<_ACEOF
10708 < /* confdefs.h.  */
10709 < _ACEOF
10710 < cat confdefs.h >>conftest.$ac_ext
10711 < cat >>conftest.$ac_ext <<_ACEOF
10712 < /* end confdefs.h.  */
10713 < $ac_includes_default
10714 < #ifdef FC_DUMMY_MAIN
10715 < #ifndef FC_DUMMY_MAIN_EQ_F77
10716 < #  ifdef __cplusplus
10717 <     extern "C"
10718 < #  endif
10719 <   int FC_DUMMY_MAIN() { return 1; }
10720 < #endif
10721 < #endif
10722 < int
10723 < main ()
10724 < {
10725 < if (sizeof (size_t))
10726 <       return 0;
10727 <  ;
10728 <  return 0;
10729 < }
10730 < _ACEOF
10731 < rm -f conftest.$ac_objext
10732 < if { (ac_try="$ac_compile"
10733 < case "(($ac_try" in
10734 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10735 <  *) ac_try_echo=$ac_try;;
10736 < esac
10737 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10738 < $as_echo "$ac_try_echo") >&5
10739 <  (eval "$ac_compile") 2>conftest.er1
10740 <  ac_status=$?
10741 <  grep -v '^ *+' conftest.er1 >conftest.err
10742 <  rm -f conftest.er1
10743 <  cat conftest.err >&5
10744 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10745 <  (exit $ac_status); } && {
10746 <         test -z "$ac_c_werror_flag" ||
10747 <         test ! -s conftest.err
10748 <       } && test -s conftest.$ac_objext; then
10749 <  cat >conftest.$ac_ext <<_ACEOF
10750 < /* confdefs.h.  */
10751 < _ACEOF
10752 < cat confdefs.h >>conftest.$ac_ext
10753 < cat >>conftest.$ac_ext <<_ACEOF
10754 < /* end confdefs.h.  */
10755 < $ac_includes_default
10756 < #ifdef FC_DUMMY_MAIN
10757 < #ifndef FC_DUMMY_MAIN_EQ_F77
10758 < #  ifdef __cplusplus
10759 <     extern "C"
10760 < #  endif
10761 <   int FC_DUMMY_MAIN() { return 1; }
10762 < #endif
10763 < #endif
10764 < int
10765 < main ()
10766 < {
10767 < if (sizeof ((size_t)))
10768 <          return 0;
10769 <  ;
10770 <  return 0;
10771 < }
10772 < _ACEOF
10773 < rm -f conftest.$ac_objext
10774 < if { (ac_try="$ac_compile"
10775 < case "(($ac_try" in
10776 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10777 <  *) ac_try_echo=$ac_try;;
10778 < esac
10779 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10780 < $as_echo "$ac_try_echo") >&5
10781 <  (eval "$ac_compile") 2>conftest.er1
10782 <  ac_status=$?
10783 <  grep -v '^ *+' conftest.er1 >conftest.err
10784 <  rm -f conftest.er1
10785 <  cat conftest.err >&5
10786 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10787 <  (exit $ac_status); } && {
10788 <         test -z "$ac_c_werror_flag" ||
10789 <         test ! -s conftest.err
10790 <       } && test -s conftest.$ac_objext; then
10791 <  :
10792 < else
10793 <  $as_echo "$as_me: failed program was:" >&5
10794 < sed 's/^/| /' conftest.$ac_ext >&5
9844 > ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
9845 > if test "x$ac_cv_type_size_t" = x""yes; then :
9846  
10796 –        ac_cv_type_size_t=yes
10797 – fi
10798 –
10799 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9847   else
10801 –  $as_echo "$as_me: failed program was:" >&5
10802 – sed 's/^/| /' conftest.$ac_ext >&5
9848  
10804 –
10805 – fi
10806 –
10807 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10808 – fi
10809 – { $as_echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
10810 – $as_echo "$ac_cv_type_size_t" >&6; }
10811 – if test $ac_cv_type_size_t = yes; then
10812 –  :
10813 – else
10814 –
9849   cat >>confdefs.h <<_ACEOF
9850   #define size_t unsigned int
9851   _ACEOF
9852  
9853   fi
9854  
9855 < { $as_echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
9855 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
9856   $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
9857 < if test "${ac_cv_header_time+set}" = set; then
9857 > if test "${ac_cv_header_time+set}" = set; then :
9858    $as_echo_n "(cached) " >&6
9859   else
9860 <  cat >conftest.$ac_ext <<_ACEOF
10827 < /* confdefs.h.  */
10828 < _ACEOF
10829 < cat confdefs.h >>conftest.$ac_ext
10830 < cat >>conftest.$ac_ext <<_ACEOF
9860 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9861   /* end confdefs.h.  */
9862   #include <sys/types.h>
9863   #include <sys/time.h>
# Line 10850 | Line 9880 | _ACEOF
9880    return 0;
9881   }
9882   _ACEOF
9883 < rm -f conftest.$ac_objext
10854 < if { (ac_try="$ac_compile"
10855 < case "(($ac_try" in
10856 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10857 <  *) ac_try_echo=$ac_try;;
10858 < esac
10859 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10860 < $as_echo "$ac_try_echo") >&5
10861 <  (eval "$ac_compile") 2>conftest.er1
10862 <  ac_status=$?
10863 <  grep -v '^ *+' conftest.er1 >conftest.err
10864 <  rm -f conftest.er1
10865 <  cat conftest.err >&5
10866 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10867 <  (exit $ac_status); } && {
10868 <         test -z "$ac_c_werror_flag" ||
10869 <         test ! -s conftest.err
10870 <       } && test -s conftest.$ac_objext; then
9883 > if ac_fn_c_try_compile "$LINENO"; then :
9884    ac_cv_header_time=yes
9885   else
9886 <  $as_echo "$as_me: failed program was:" >&5
10874 < sed 's/^/| /' conftest.$ac_ext >&5
10875 <
10876 <        ac_cv_header_time=no
9886 >  ac_cv_header_time=no
9887   fi
10878 –
9888   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9889   fi
9890 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
9890 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
9891   $as_echo "$ac_cv_header_time" >&6; }
9892   if test $ac_cv_header_time = yes; then
9893  
9894 < cat >>confdefs.h <<\_ACEOF
10886 < #define TIME_WITH_SYS_TIME 1
10887 < _ACEOF
9894 > $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
9895  
9896   fi
9897  
9898  
9899   # Checks for library functions.
10893 –
9900   for ac_header in stdlib.h
9901 < do
9902 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
9903 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10898 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10899 < $as_echo_n "checking for $ac_header... " >&6; }
10900 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10901 <  $as_echo_n "(cached) " >&6
10902 < fi
10903 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10904 <                 $as_echo "$as_val"'`
10905 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10906 < $as_echo "$ac_res" >&6; }
10907 < else
10908 <  # Is the header compilable?
10909 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10910 < $as_echo_n "checking $ac_header usability... " >&6; }
10911 < cat >conftest.$ac_ext <<_ACEOF
10912 < /* confdefs.h.  */
10913 < _ACEOF
10914 < cat confdefs.h >>conftest.$ac_ext
10915 < cat >>conftest.$ac_ext <<_ACEOF
10916 < /* end confdefs.h.  */
10917 < $ac_includes_default
10918 < #include <$ac_header>
10919 < _ACEOF
10920 < rm -f conftest.$ac_objext
10921 < if { (ac_try="$ac_compile"
10922 < case "(($ac_try" in
10923 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10924 <  *) ac_try_echo=$ac_try;;
10925 < esac
10926 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10927 < $as_echo "$ac_try_echo") >&5
10928 <  (eval "$ac_compile") 2>conftest.er1
10929 <  ac_status=$?
10930 <  grep -v '^ *+' conftest.er1 >conftest.err
10931 <  rm -f conftest.er1
10932 <  cat conftest.err >&5
10933 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10934 <  (exit $ac_status); } && {
10935 <         test -z "$ac_c_werror_flag" ||
10936 <         test ! -s conftest.err
10937 <       } && test -s conftest.$ac_objext; then
10938 <  ac_header_compiler=yes
10939 < else
10940 <  $as_echo "$as_me: failed program was:" >&5
10941 < sed 's/^/| /' conftest.$ac_ext >&5
10942 <
10943 <        ac_header_compiler=no
10944 < fi
10945 <
10946 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10947 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10948 < $as_echo "$ac_header_compiler" >&6; }
10949 <
10950 < # Is the header present?
10951 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10952 < $as_echo_n "checking $ac_header presence... " >&6; }
10953 < cat >conftest.$ac_ext <<_ACEOF
10954 < /* confdefs.h.  */
10955 < _ACEOF
10956 < cat confdefs.h >>conftest.$ac_ext
10957 < cat >>conftest.$ac_ext <<_ACEOF
10958 < /* end confdefs.h.  */
10959 < #include <$ac_header>
10960 < _ACEOF
10961 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10962 < case "(($ac_try" in
10963 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10964 <  *) ac_try_echo=$ac_try;;
10965 < esac
10966 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10967 < $as_echo "$ac_try_echo") >&5
10968 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10969 <  ac_status=$?
10970 <  grep -v '^ *+' conftest.er1 >conftest.err
10971 <  rm -f conftest.er1
10972 <  cat conftest.err >&5
10973 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10974 <  (exit $ac_status); } >/dev/null && {
10975 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10976 <         test ! -s conftest.err
10977 <       }; then
10978 <  ac_header_preproc=yes
10979 < else
10980 <  $as_echo "$as_me: failed program was:" >&5
10981 < sed 's/^/| /' conftest.$ac_ext >&5
10982 <
10983 <  ac_header_preproc=no
10984 < fi
10985 <
10986 < rm -f conftest.err conftest.$ac_ext
10987 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10988 < $as_echo "$ac_header_preproc" >&6; }
10989 <
10990 < # So?  What about this header?
10991 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10992 <  yes:no: )
10993 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10994 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10995 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10996 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10997 <    ac_header_preproc=yes
10998 <    ;;
10999 <  no:yes:* )
11000 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11001 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11002 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11003 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11004 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11005 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11006 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11007 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11008 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11009 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11010 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11011 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11012 <    ( cat <<\_ASBOX
11013 < ## ------------------------------ ##
11014 < ## Report this to gezelter@nd.edu ##
11015 < ## ------------------------------ ##
11016 < _ASBOX
11017 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11018 <    ;;
11019 < esac
11020 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11021 < $as_echo_n "checking for $ac_header... " >&6; }
11022 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11023 <  $as_echo_n "(cached) " >&6
11024 < else
11025 <  eval "$as_ac_Header=\$ac_header_preproc"
11026 < fi
11027 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11028 <                 $as_echo "$as_val"'`
11029 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11030 < $as_echo "$ac_res" >&6; }
11031 <
11032 < fi
11033 < if test `eval 'as_val=${'$as_ac_Header'}
11034 <                 $as_echo "$as_val"'` = yes; then
9901 > do :
9902 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
9903 > if test "x$ac_cv_header_stdlib_h" = x""yes; then :
9904    cat >>confdefs.h <<_ACEOF
9905 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
9905 > #define HAVE_STDLIB_H 1
9906   _ACEOF
9907  
9908   fi
9909  
9910   done
9911  
9912 < { $as_echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
9912 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
9913   $as_echo_n "checking for GNU libc compatible malloc... " >&6; }
9914 < if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
9914 > if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then :
9915    $as_echo_n "(cached) " >&6
9916   else
9917 <  if test "$cross_compiling" = yes; then
9917 >  if test "$cross_compiling" = yes; then :
9918    ac_cv_func_malloc_0_nonnull=no
9919   else
9920 <  cat >conftest.$ac_ext <<_ACEOF
11052 < /* confdefs.h.  */
11053 < _ACEOF
11054 < cat confdefs.h >>conftest.$ac_ext
11055 < cat >>conftest.$ac_ext <<_ACEOF
9920 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9921   /* end confdefs.h.  */
9922   #if defined STDC_HEADERS || defined HAVE_STDLIB_H
9923   # include <stdlib.h>
# Line 11076 | Line 9941 | _ACEOF
9941    return 0;
9942   }
9943   _ACEOF
9944 < rm -f conftest$ac_exeext
11080 < if { (ac_try="$ac_link"
11081 < case "(($ac_try" in
11082 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11083 <  *) ac_try_echo=$ac_try;;
11084 < esac
11085 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11086 < $as_echo "$ac_try_echo") >&5
11087 <  (eval "$ac_link") 2>&5
11088 <  ac_status=$?
11089 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11090 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11091 <  { (case "(($ac_try" in
11092 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11093 <  *) ac_try_echo=$ac_try;;
11094 < esac
11095 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11096 < $as_echo "$ac_try_echo") >&5
11097 <  (eval "$ac_try") 2>&5
11098 <  ac_status=$?
11099 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11100 <  (exit $ac_status); }; }; then
9944 > if ac_fn_c_try_run "$LINENO"; then :
9945    ac_cv_func_malloc_0_nonnull=yes
9946   else
9947 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11104 < $as_echo "$as_me: failed program was:" >&5
11105 < sed 's/^/| /' conftest.$ac_ext >&5
11106 <
11107 < ( exit $ac_status )
11108 < ac_cv_func_malloc_0_nonnull=no
9947 >  ac_cv_func_malloc_0_nonnull=no
9948   fi
9949 < rm -rf conftest.dSYM
9950 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9949 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
9950 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
9951   fi
9952  
11114 –
9953   fi
9954 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
9954 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
9955   $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
9956 < if test $ac_cv_func_malloc_0_nonnull = yes; then
9956 > if test $ac_cv_func_malloc_0_nonnull = yes; then :
9957  
9958 < cat >>confdefs.h <<\_ACEOF
11121 < #define HAVE_MALLOC 1
11122 < _ACEOF
9958 > $as_echo "#define HAVE_MALLOC 1" >>confdefs.h
9959  
9960   else
9961 <  cat >>confdefs.h <<\_ACEOF
11126 < #define HAVE_MALLOC 0
11127 < _ACEOF
9961 >  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
9962  
9963     case " $LIBOBJS " in
9964    *" malloc.$ac_objext "* ) ;;
# Line 11133 | Line 9967 | esac
9967   esac
9968  
9969  
9970 < cat >>confdefs.h <<\_ACEOF
11137 < #define malloc rpl_malloc
11138 < _ACEOF
9970 > $as_echo "#define malloc rpl_malloc" >>confdefs.h
9971  
9972   fi
9973  
9974  
11143 –
11144 –
9975   for ac_header in stdlib.h
9976 < do
9977 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
9978 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11149 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11150 < $as_echo_n "checking for $ac_header... " >&6; }
11151 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11152 <  $as_echo_n "(cached) " >&6
11153 < fi
11154 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11155 <                 $as_echo "$as_val"'`
11156 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11157 < $as_echo "$ac_res" >&6; }
11158 < else
11159 <  # Is the header compilable?
11160 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11161 < $as_echo_n "checking $ac_header usability... " >&6; }
11162 < cat >conftest.$ac_ext <<_ACEOF
11163 < /* confdefs.h.  */
11164 < _ACEOF
11165 < cat confdefs.h >>conftest.$ac_ext
11166 < cat >>conftest.$ac_ext <<_ACEOF
11167 < /* end confdefs.h.  */
11168 < $ac_includes_default
11169 < #include <$ac_header>
11170 < _ACEOF
11171 < rm -f conftest.$ac_objext
11172 < if { (ac_try="$ac_compile"
11173 < case "(($ac_try" in
11174 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11175 <  *) ac_try_echo=$ac_try;;
11176 < esac
11177 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11178 < $as_echo "$ac_try_echo") >&5
11179 <  (eval "$ac_compile") 2>conftest.er1
11180 <  ac_status=$?
11181 <  grep -v '^ *+' conftest.er1 >conftest.err
11182 <  rm -f conftest.er1
11183 <  cat conftest.err >&5
11184 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11185 <  (exit $ac_status); } && {
11186 <         test -z "$ac_c_werror_flag" ||
11187 <         test ! -s conftest.err
11188 <       } && test -s conftest.$ac_objext; then
11189 <  ac_header_compiler=yes
11190 < else
11191 <  $as_echo "$as_me: failed program was:" >&5
11192 < sed 's/^/| /' conftest.$ac_ext >&5
11193 <
11194 <        ac_header_compiler=no
11195 < fi
11196 <
11197 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11198 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11199 < $as_echo "$ac_header_compiler" >&6; }
11200 <
11201 < # Is the header present?
11202 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11203 < $as_echo_n "checking $ac_header presence... " >&6; }
11204 < cat >conftest.$ac_ext <<_ACEOF
11205 < /* confdefs.h.  */
11206 < _ACEOF
11207 < cat confdefs.h >>conftest.$ac_ext
11208 < cat >>conftest.$ac_ext <<_ACEOF
11209 < /* end confdefs.h.  */
11210 < #include <$ac_header>
11211 < _ACEOF
11212 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11213 < case "(($ac_try" in
11214 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11215 <  *) ac_try_echo=$ac_try;;
11216 < esac
11217 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11218 < $as_echo "$ac_try_echo") >&5
11219 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11220 <  ac_status=$?
11221 <  grep -v '^ *+' conftest.er1 >conftest.err
11222 <  rm -f conftest.er1
11223 <  cat conftest.err >&5
11224 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11225 <  (exit $ac_status); } >/dev/null && {
11226 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11227 <         test ! -s conftest.err
11228 <       }; then
11229 <  ac_header_preproc=yes
11230 < else
11231 <  $as_echo "$as_me: failed program was:" >&5
11232 < sed 's/^/| /' conftest.$ac_ext >&5
11233 <
11234 <  ac_header_preproc=no
11235 < fi
11236 <
11237 < rm -f conftest.err conftest.$ac_ext
11238 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11239 < $as_echo "$ac_header_preproc" >&6; }
11240 <
11241 < # So?  What about this header?
11242 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11243 <  yes:no: )
11244 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11245 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11246 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11247 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11248 <    ac_header_preproc=yes
11249 <    ;;
11250 <  no:yes:* )
11251 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11252 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11253 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11254 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11255 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11256 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11257 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11258 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11259 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11260 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11261 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11262 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11263 <    ( cat <<\_ASBOX
11264 < ## ------------------------------ ##
11265 < ## Report this to gezelter@nd.edu ##
11266 < ## ------------------------------ ##
11267 < _ASBOX
11268 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11269 <    ;;
11270 < esac
11271 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11272 < $as_echo_n "checking for $ac_header... " >&6; }
11273 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11274 <  $as_echo_n "(cached) " >&6
11275 < else
11276 <  eval "$as_ac_Header=\$ac_header_preproc"
11277 < fi
11278 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11279 <                 $as_echo "$as_val"'`
11280 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11281 < $as_echo "$ac_res" >&6; }
11282 <
11283 < fi
11284 < if test `eval 'as_val=${'$as_ac_Header'}
11285 <                 $as_echo "$as_val"'` = yes; then
9976 > do :
9977 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
9978 > if test "x$ac_cv_header_stdlib_h" = x""yes; then :
9979    cat >>confdefs.h <<_ACEOF
9980 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
9980 > #define HAVE_STDLIB_H 1
9981   _ACEOF
9982  
9983   fi
9984  
9985   done
9986  
9987 < { $as_echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
9987 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
9988   $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
9989 < if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
9989 > if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then :
9990    $as_echo_n "(cached) " >&6
9991   else
9992 <  if test "$cross_compiling" = yes; then
9992 >  if test "$cross_compiling" = yes; then :
9993    ac_cv_func_realloc_0_nonnull=no
9994   else
9995 <  cat >conftest.$ac_ext <<_ACEOF
11303 < /* confdefs.h.  */
11304 < _ACEOF
11305 < cat confdefs.h >>conftest.$ac_ext
11306 < cat >>conftest.$ac_ext <<_ACEOF
9995 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
9996   /* end confdefs.h.  */
9997   #if defined STDC_HEADERS || defined HAVE_STDLIB_H
9998   # include <stdlib.h>
# Line 11327 | Line 10016 | _ACEOF
10016    return 0;
10017   }
10018   _ACEOF
10019 < rm -f conftest$ac_exeext
11331 < if { (ac_try="$ac_link"
11332 < case "(($ac_try" in
11333 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11334 <  *) ac_try_echo=$ac_try;;
11335 < esac
11336 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11337 < $as_echo "$ac_try_echo") >&5
11338 <  (eval "$ac_link") 2>&5
11339 <  ac_status=$?
11340 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11341 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11342 <  { (case "(($ac_try" in
11343 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11344 <  *) ac_try_echo=$ac_try;;
11345 < esac
11346 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11347 < $as_echo "$ac_try_echo") >&5
11348 <  (eval "$ac_try") 2>&5
11349 <  ac_status=$?
11350 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11351 <  (exit $ac_status); }; }; then
10019 > if ac_fn_c_try_run "$LINENO"; then :
10020    ac_cv_func_realloc_0_nonnull=yes
10021   else
10022 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11355 < $as_echo "$as_me: failed program was:" >&5
11356 < sed 's/^/| /' conftest.$ac_ext >&5
11357 <
11358 < ( exit $ac_status )
11359 < ac_cv_func_realloc_0_nonnull=no
10022 >  ac_cv_func_realloc_0_nonnull=no
10023   fi
10024 < rm -rf conftest.dSYM
10025 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10024 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
10025 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
10026   fi
10027  
11365 –
10028   fi
10029 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
10029 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
10030   $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
10031 < if test $ac_cv_func_realloc_0_nonnull = yes; then
10031 > if test $ac_cv_func_realloc_0_nonnull = yes; then :
10032  
10033 < cat >>confdefs.h <<\_ACEOF
11372 < #define HAVE_REALLOC 1
11373 < _ACEOF
10033 > $as_echo "#define HAVE_REALLOC 1" >>confdefs.h
10034  
10035   else
10036 <  cat >>confdefs.h <<\_ACEOF
11377 < #define HAVE_REALLOC 0
11378 < _ACEOF
10036 >  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
10037  
10038     case " $LIBOBJS " in
10039    *" realloc.$ac_objext "* ) ;;
# Line 11384 | Line 10042 | esac
10042   esac
10043  
10044  
10045 < cat >>confdefs.h <<\_ACEOF
11388 < #define realloc rpl_realloc
11389 < _ACEOF
10045 > $as_echo "#define realloc rpl_realloc" >>confdefs.h
10046  
10047   fi
10048  
10049  
11394 –
11395 –
11396 –
10050   for ac_header in sys/select.h sys/socket.h
10051 < do
10052 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
10053 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10054 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10055 < $as_echo_n "checking for $ac_header... " >&6; }
11403 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11404 <  $as_echo_n "(cached) " >&6
11405 < fi
11406 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11407 <                 $as_echo "$as_val"'`
11408 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11409 < $as_echo "$ac_res" >&6; }
11410 < else
11411 <  # Is the header compilable?
11412 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11413 < $as_echo_n "checking $ac_header usability... " >&6; }
11414 < cat >conftest.$ac_ext <<_ACEOF
11415 < /* confdefs.h.  */
11416 < _ACEOF
11417 < cat confdefs.h >>conftest.$ac_ext
11418 < cat >>conftest.$ac_ext <<_ACEOF
11419 < /* end confdefs.h.  */
11420 < $ac_includes_default
11421 < #include <$ac_header>
11422 < _ACEOF
11423 < rm -f conftest.$ac_objext
11424 < if { (ac_try="$ac_compile"
11425 < case "(($ac_try" in
11426 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11427 <  *) ac_try_echo=$ac_try;;
11428 < esac
11429 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11430 < $as_echo "$ac_try_echo") >&5
11431 <  (eval "$ac_compile") 2>conftest.er1
11432 <  ac_status=$?
11433 <  grep -v '^ *+' conftest.er1 >conftest.err
11434 <  rm -f conftest.er1
11435 <  cat conftest.err >&5
11436 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11437 <  (exit $ac_status); } && {
11438 <         test -z "$ac_c_werror_flag" ||
11439 <         test ! -s conftest.err
11440 <       } && test -s conftest.$ac_objext; then
11441 <  ac_header_compiler=yes
11442 < else
11443 <  $as_echo "$as_me: failed program was:" >&5
11444 < sed 's/^/| /' conftest.$ac_ext >&5
11445 <
11446 <        ac_header_compiler=no
11447 < fi
11448 <
11449 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11450 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11451 < $as_echo "$ac_header_compiler" >&6; }
11452 <
11453 < # Is the header present?
11454 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11455 < $as_echo_n "checking $ac_header presence... " >&6; }
11456 < cat >conftest.$ac_ext <<_ACEOF
11457 < /* confdefs.h.  */
11458 < _ACEOF
11459 < cat confdefs.h >>conftest.$ac_ext
11460 < cat >>conftest.$ac_ext <<_ACEOF
11461 < /* end confdefs.h.  */
11462 < #include <$ac_header>
11463 < _ACEOF
11464 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11465 < case "(($ac_try" in
11466 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11467 <  *) ac_try_echo=$ac_try;;
11468 < esac
11469 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11470 < $as_echo "$ac_try_echo") >&5
11471 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11472 <  ac_status=$?
11473 <  grep -v '^ *+' conftest.er1 >conftest.err
11474 <  rm -f conftest.er1
11475 <  cat conftest.err >&5
11476 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11477 <  (exit $ac_status); } >/dev/null && {
11478 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11479 <         test ! -s conftest.err
11480 <       }; then
11481 <  ac_header_preproc=yes
11482 < else
11483 <  $as_echo "$as_me: failed program was:" >&5
11484 < sed 's/^/| /' conftest.$ac_ext >&5
11485 <
11486 <  ac_header_preproc=no
11487 < fi
11488 <
11489 < rm -f conftest.err conftest.$ac_ext
11490 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11491 < $as_echo "$ac_header_preproc" >&6; }
11492 <
11493 < # So?  What about this header?
11494 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11495 <  yes:no: )
11496 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11497 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11498 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11499 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11500 <    ac_header_preproc=yes
11501 <    ;;
11502 <  no:yes:* )
11503 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11504 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11505 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11506 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11507 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11508 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11509 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11510 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11511 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11512 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11513 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11514 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11515 <    ( cat <<\_ASBOX
11516 < ## ------------------------------ ##
11517 < ## Report this to gezelter@nd.edu ##
11518 < ## ------------------------------ ##
11519 < _ASBOX
11520 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11521 <    ;;
11522 < esac
11523 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11524 < $as_echo_n "checking for $ac_header... " >&6; }
11525 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11526 <  $as_echo_n "(cached) " >&6
11527 < else
11528 <  eval "$as_ac_Header=\$ac_header_preproc"
11529 < fi
11530 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11531 <                 $as_echo "$as_val"'`
11532 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11533 < $as_echo "$ac_res" >&6; }
11534 <
11535 < fi
11536 < if test `eval 'as_val=${'$as_ac_Header'}
11537 <                 $as_echo "$as_val"'` = yes; then
10051 > do :
10052 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
10053 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
10054 > eval as_val=\$$as_ac_Header
10055 >   if test "x$as_val" = x""yes; then :
10056    cat >>confdefs.h <<_ACEOF
10057   #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
10058   _ACEOF
# Line 11543 | Line 10061 | done
10061  
10062   done
10063  
10064 < { $as_echo "$as_me:$LINENO: checking types of arguments for select" >&5
10064 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking types of arguments for select" >&5
10065   $as_echo_n "checking types of arguments for select... " >&6; }
10066 < if test "${ac_cv_func_select_args+set}" = set; then
10066 > if test "${ac_cv_func_select_args+set}" = set; then :
10067    $as_echo_n "(cached) " >&6
10068   else
10069    for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
10070   for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
10071    for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
10072 <   cat >conftest.$ac_ext <<_ACEOF
11555 < /* confdefs.h.  */
11556 < _ACEOF
11557 < cat confdefs.h >>conftest.$ac_ext
11558 < cat >>conftest.$ac_ext <<_ACEOF
10072 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10073   /* end confdefs.h.  */
10074   $ac_includes_default
10075   #ifdef HAVE_SYS_SELECT_H
# Line 11583 | Line 10097 | _ACEOF
10097    return 0;
10098   }
10099   _ACEOF
10100 < rm -f conftest.$ac_objext
11587 < if { (ac_try="$ac_compile"
11588 < case "(($ac_try" in
11589 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11590 <  *) ac_try_echo=$ac_try;;
11591 < esac
11592 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11593 < $as_echo "$ac_try_echo") >&5
11594 <  (eval "$ac_compile") 2>conftest.er1
11595 <  ac_status=$?
11596 <  grep -v '^ *+' conftest.er1 >conftest.err
11597 <  rm -f conftest.er1
11598 <  cat conftest.err >&5
11599 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11600 <  (exit $ac_status); } && {
11601 <         test -z "$ac_c_werror_flag" ||
11602 <         test ! -s conftest.err
11603 <       } && test -s conftest.$ac_objext; then
10100 > if ac_fn_c_try_compile "$LINENO"; then :
10101    ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
11605 – else
11606 –  $as_echo "$as_me: failed program was:" >&5
11607 – sed 's/^/| /' conftest.$ac_ext >&5
11608 –
11609 –
10102   fi
11611 –
10103   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10104    done
10105   done
# Line 11617 | Line 10108 | fi
10108   : ${ac_cv_func_select_args='int,int *,struct timeval *'}
10109  
10110   fi
10111 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
10111 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_select_args" >&5
10112   $as_echo "$ac_cv_func_select_args" >&6; }
10113   ac_save_IFS=$IFS; IFS=','
10114   set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
# Line 11640 | Line 10131 | rm -f conftest*
10131  
10132   rm -f conftest*
10133  
10134 < { $as_echo "$as_me:$LINENO: checking for working strtod" >&5
10134 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
10135   $as_echo_n "checking for working strtod... " >&6; }
10136 < if test "${ac_cv_func_strtod+set}" = set; then
10136 > if test "${ac_cv_func_strtod+set}" = set; then :
10137    $as_echo_n "(cached) " >&6
10138   else
10139 <  if test "$cross_compiling" = yes; then
10139 >  if test "$cross_compiling" = yes; then :
10140    ac_cv_func_strtod=no
10141   else
10142 <  cat >conftest.$ac_ext <<_ACEOF
11652 < /* confdefs.h.  */
11653 < _ACEOF
11654 < cat confdefs.h >>conftest.$ac_ext
11655 < cat >>conftest.$ac_ext <<_ACEOF
10142 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10143   /* end confdefs.h.  */
10144  
10145   $ac_includes_default
# Line 11685 | Line 10172 | _ACEOF
10172   }
10173  
10174   _ACEOF
10175 < rm -f conftest$ac_exeext
11689 < if { (ac_try="$ac_link"
11690 < case "(($ac_try" in
11691 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11692 <  *) ac_try_echo=$ac_try;;
11693 < esac
11694 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11695 < $as_echo "$ac_try_echo") >&5
11696 <  (eval "$ac_link") 2>&5
11697 <  ac_status=$?
11698 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11699 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11700 <  { (case "(($ac_try" in
11701 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11702 <  *) ac_try_echo=$ac_try;;
11703 < esac
11704 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11705 < $as_echo "$ac_try_echo") >&5
11706 <  (eval "$ac_try") 2>&5
11707 <  ac_status=$?
11708 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11709 <  (exit $ac_status); }; }; then
10175 > if ac_fn_c_try_run "$LINENO"; then :
10176    ac_cv_func_strtod=yes
10177   else
10178 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11713 < $as_echo "$as_me: failed program was:" >&5
11714 < sed 's/^/| /' conftest.$ac_ext >&5
11715 <
11716 < ( exit $ac_status )
11717 < ac_cv_func_strtod=no
10178 >  ac_cv_func_strtod=no
10179   fi
10180 < rm -rf conftest.dSYM
10181 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10180 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
10181 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
10182   fi
10183  
11723 –
10184   fi
10185 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
10185 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
10186   $as_echo "$ac_cv_func_strtod" >&6; }
10187   if test $ac_cv_func_strtod = no; then
10188    case " $LIBOBJS " in
# Line 11731 | Line 10191 | esac
10191   ;;
10192   esac
10193  
10194 < { $as_echo "$as_me:$LINENO: checking for pow" >&5
10195 < $as_echo_n "checking for pow... " >&6; }
11736 < if test "${ac_cv_func_pow+set}" = set; then
11737 <  $as_echo_n "(cached) " >&6
11738 < else
11739 <  cat >conftest.$ac_ext <<_ACEOF
11740 < /* confdefs.h.  */
11741 < _ACEOF
11742 < cat confdefs.h >>conftest.$ac_ext
11743 < cat >>conftest.$ac_ext <<_ACEOF
11744 < /* end confdefs.h.  */
11745 < /* Define pow to an innocuous variant, in case <limits.h> declares pow.
11746 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11747 < #define pow innocuous_pow
10194 > ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
10195 > if test "x$ac_cv_func_pow" = x""yes; then :
10196  
11749 – /* System header to define __stub macros and hopefully few prototypes,
11750 –    which can conflict with char pow (); below.
11751 –    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11752 –    <limits.h> exists even on freestanding compilers.  */
11753 –
11754 – #ifdef __STDC__
11755 – # include <limits.h>
11756 – #else
11757 – # include <assert.h>
11758 – #endif
11759 –
11760 – #undef pow
11761 –
11762 – /* Override any GCC internal prototype to avoid an error.
11763 –   Use char because int might match the return type of a GCC
11764 –   builtin and then its argument prototype would still apply.  */
11765 – #ifdef __cplusplus
11766 – extern "C"
11767 – #endif
11768 – char pow ();
11769 – /* The GNU C library defines this for functions which it implements
11770 –    to always fail with ENOSYS.  Some functions are actually named
11771 –    something starting with __ and the normal name is an alias.  */
11772 – #if defined __stub_pow || defined __stub___pow
11773 – choke me
11774 – #endif
11775 –
11776 – #ifdef FC_DUMMY_MAIN
11777 – #ifndef FC_DUMMY_MAIN_EQ_F77
11778 – #  ifdef __cplusplus
11779 –     extern "C"
11780 – #  endif
11781 –   int FC_DUMMY_MAIN() { return 1; }
11782 – #endif
11783 – #endif
11784 – int
11785 – main ()
11786 – {
11787 – return pow ();
11788 –  ;
11789 –  return 0;
11790 – }
11791 – _ACEOF
11792 – rm -f conftest.$ac_objext conftest$ac_exeext
11793 – if { (ac_try="$ac_link"
11794 – case "(($ac_try" in
11795 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11796 –  *) ac_try_echo=$ac_try;;
11797 – esac
11798 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11799 – $as_echo "$ac_try_echo") >&5
11800 –  (eval "$ac_link") 2>conftest.er1
11801 –  ac_status=$?
11802 –  grep -v '^ *+' conftest.er1 >conftest.err
11803 –  rm -f conftest.er1
11804 –  cat conftest.err >&5
11805 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11806 –  (exit $ac_status); } && {
11807 –         test -z "$ac_c_werror_flag" ||
11808 –         test ! -s conftest.err
11809 –       } && test -s conftest$ac_exeext && {
11810 –         test "$cross_compiling" = yes ||
11811 –         $as_test_x conftest$ac_exeext
11812 –       }; then
11813 –  ac_cv_func_pow=yes
11814 – else
11815 –  $as_echo "$as_me: failed program was:" >&5
11816 – sed 's/^/| /' conftest.$ac_ext >&5
11817 –
11818 –        ac_cv_func_pow=no
10197   fi
10198  
11821 – rm -rf conftest.dSYM
11822 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11823 –      conftest$ac_exeext conftest.$ac_ext
11824 – fi
11825 – { $as_echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11826 – $as_echo "$ac_cv_func_pow" >&6; }
11827 –
10199   if test $ac_cv_func_pow = no; then
10200 <  { $as_echo "$as_me:$LINENO: checking for pow in -lm" >&5
10200 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
10201   $as_echo_n "checking for pow in -lm... " >&6; }
10202 < if test "${ac_cv_lib_m_pow+set}" = set; then
10202 > if test "${ac_cv_lib_m_pow+set}" = set; then :
10203    $as_echo_n "(cached) " >&6
10204   else
10205    ac_check_lib_save_LIBS=$LIBS
10206   LIBS="-lm  $LIBS"
10207 < cat >conftest.$ac_ext <<_ACEOF
11837 < /* confdefs.h.  */
11838 < _ACEOF
11839 < cat confdefs.h >>conftest.$ac_ext
11840 < cat >>conftest.$ac_ext <<_ACEOF
10207 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10208   /* end confdefs.h.  */
10209  
10210   /* Override any GCC internal prototype to avoid an error.
# Line 11863 | Line 10230 | _ACEOF
10230    return 0;
10231   }
10232   _ACEOF
10233 < rm -f conftest.$ac_objext conftest$ac_exeext
11867 < if { (ac_try="$ac_link"
11868 < case "(($ac_try" in
11869 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11870 <  *) ac_try_echo=$ac_try;;
11871 < esac
11872 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11873 < $as_echo "$ac_try_echo") >&5
11874 <  (eval "$ac_link") 2>conftest.er1
11875 <  ac_status=$?
11876 <  grep -v '^ *+' conftest.er1 >conftest.err
11877 <  rm -f conftest.er1
11878 <  cat conftest.err >&5
11879 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11880 <  (exit $ac_status); } && {
11881 <         test -z "$ac_c_werror_flag" ||
11882 <         test ! -s conftest.err
11883 <       } && test -s conftest$ac_exeext && {
11884 <         test "$cross_compiling" = yes ||
11885 <         $as_test_x conftest$ac_exeext
11886 <       }; then
10233 > if ac_fn_c_try_link "$LINENO"; then :
10234    ac_cv_lib_m_pow=yes
10235   else
10236 <  $as_echo "$as_me: failed program was:" >&5
11890 < sed 's/^/| /' conftest.$ac_ext >&5
11891 <
11892 <        ac_cv_lib_m_pow=no
10236 >  ac_cv_lib_m_pow=no
10237   fi
10238 <
10239 < rm -rf conftest.dSYM
11896 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11897 <      conftest$ac_exeext conftest.$ac_ext
10238 > rm -f core conftest.err conftest.$ac_objext \
10239 >    conftest$ac_exeext conftest.$ac_ext
10240   LIBS=$ac_check_lib_save_LIBS
10241   fi
10242 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
10242 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
10243   $as_echo "$ac_cv_lib_m_pow" >&6; }
10244 < if test $ac_cv_lib_m_pow = yes; then
10244 > if test "x$ac_cv_lib_m_pow" = x""yes; then :
10245    POW_LIB=-lm
10246   else
10247 <  { $as_echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
10247 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
10248   $as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
10249   fi
10250  
# Line 11910 | Line 10252 | fi
10252  
10253   fi
10254  
11913 –
11914 –
11915 –
11916 –
11917 –
11918 –
11919 –
11920 –
11921 –
11922 –
11923 –
11924 –
11925 –
11926 –
11927 –
11928 –
11929 –
11930 –
11931 –
11932 –
11933 –
10255   for ac_func in floor getpagesize gettimeofday memset pow pstat_getdynamic pstat_getstatic select sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strstr strtol sysmp getsysinfo sysctl table
10256 < do
10257 < as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
10258 < { $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
10259 < $as_echo_n "checking for $ac_func... " >&6; }
10260 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11940 <  $as_echo_n "(cached) " >&6
11941 < else
11942 <  cat >conftest.$ac_ext <<_ACEOF
11943 < /* confdefs.h.  */
11944 < _ACEOF
11945 < cat confdefs.h >>conftest.$ac_ext
11946 < cat >>conftest.$ac_ext <<_ACEOF
11947 < /* end confdefs.h.  */
11948 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11949 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11950 < #define $ac_func innocuous_$ac_func
11951 <
11952 < /* System header to define __stub macros and hopefully few prototypes,
11953 <    which can conflict with char $ac_func (); below.
11954 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11955 <    <limits.h> exists even on freestanding compilers.  */
11956 <
11957 < #ifdef __STDC__
11958 < # include <limits.h>
11959 < #else
11960 < # include <assert.h>
11961 < #endif
11962 <
11963 < #undef $ac_func
11964 <
11965 < /* Override any GCC internal prototype to avoid an error.
11966 <   Use char because int might match the return type of a GCC
11967 <   builtin and then its argument prototype would still apply.  */
11968 < #ifdef __cplusplus
11969 < extern "C"
11970 < #endif
11971 < char $ac_func ();
11972 < /* The GNU C library defines this for functions which it implements
11973 <    to always fail with ENOSYS.  Some functions are actually named
11974 <    something starting with __ and the normal name is an alias.  */
11975 < #if defined __stub_$ac_func || defined __stub___$ac_func
11976 < choke me
11977 < #endif
11978 <
11979 < #ifdef FC_DUMMY_MAIN
11980 < #ifndef FC_DUMMY_MAIN_EQ_F77
11981 < #  ifdef __cplusplus
11982 <     extern "C"
11983 < #  endif
11984 <   int FC_DUMMY_MAIN() { return 1; }
11985 < #endif
11986 < #endif
11987 < int
11988 < main ()
11989 < {
11990 < return $ac_func ();
11991 <  ;
11992 <  return 0;
11993 < }
11994 < _ACEOF
11995 < rm -f conftest.$ac_objext conftest$ac_exeext
11996 < if { (ac_try="$ac_link"
11997 < case "(($ac_try" in
11998 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11999 <  *) ac_try_echo=$ac_try;;
12000 < esac
12001 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12002 < $as_echo "$ac_try_echo") >&5
12003 <  (eval "$ac_link") 2>conftest.er1
12004 <  ac_status=$?
12005 <  grep -v '^ *+' conftest.er1 >conftest.err
12006 <  rm -f conftest.er1
12007 <  cat conftest.err >&5
12008 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12009 <  (exit $ac_status); } && {
12010 <         test -z "$ac_c_werror_flag" ||
12011 <         test ! -s conftest.err
12012 <       } && test -s conftest$ac_exeext && {
12013 <         test "$cross_compiling" = yes ||
12014 <         $as_test_x conftest$ac_exeext
12015 <       }; then
12016 <  eval "$as_ac_var=yes"
12017 < else
12018 <  $as_echo "$as_me: failed program was:" >&5
12019 < sed 's/^/| /' conftest.$ac_ext >&5
12020 <
12021 <        eval "$as_ac_var=no"
12022 < fi
12023 <
12024 < rm -rf conftest.dSYM
12025 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12026 <      conftest$ac_exeext conftest.$ac_ext
12027 < fi
12028 < ac_res=`eval 'as_val=${'$as_ac_var'}
12029 <                 $as_echo "$as_val"'`
12030 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
12031 < $as_echo "$ac_res" >&6; }
12032 < if test `eval 'as_val=${'$as_ac_var'}
12033 <                 $as_echo "$as_val"'` = yes; then
10256 > do :
10257 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
10258 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
10259 > eval as_val=\$$as_ac_var
10260 >   if test "x$as_val" = x""yes; then :
10261    cat >>confdefs.h <<_ACEOF
10262   #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
10263   _ACEOF
# Line 12041 | Line 10268 | done
10268  
10269   # special check for _system_configuration because AIX <4.3.2 do not
10270   # contain the `physmem' member.
10271 < { $as_echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
10271 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for external symbol _system_configuration" >&5
10272   $as_echo_n "checking for external symbol _system_configuration... " >&6; }
10273 < cat >conftest.$ac_ext <<_ACEOF
12047 < /* confdefs.h.  */
12048 < _ACEOF
12049 < cat confdefs.h >>conftest.$ac_ext
12050 < cat >>conftest.$ac_ext <<_ACEOF
10273 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10274   /* end confdefs.h.  */
10275   #include <sys/systemcfg.h>
10276   #ifdef FC_DUMMY_MAIN
# Line 12066 | Line 10289 | _ACEOF
10289    return 0;
10290   }
10291   _ACEOF
10292 < rm -f conftest.$ac_objext
10293 < if { (ac_try="$ac_compile"
12071 < case "(($ac_try" in
12072 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12073 <  *) ac_try_echo=$ac_try;;
12074 < esac
12075 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12076 < $as_echo "$ac_try_echo") >&5
12077 <  (eval "$ac_compile") 2>conftest.er1
12078 <  ac_status=$?
12079 <  grep -v '^ *+' conftest.er1 >conftest.err
12080 <  rm -f conftest.er1
12081 <  cat conftest.err >&5
12082 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12083 <  (exit $ac_status); } && {
12084 <         test -z "$ac_c_werror_flag" ||
12085 <         test ! -s conftest.err
12086 <       } && test -s conftest.$ac_objext; then
12087 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
10292 > if ac_fn_c_try_compile "$LINENO"; then :
10293 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
10294   $as_echo "yes" >&6; }
10295  
10296 < cat >>confdefs.h <<\_ACEOF
12091 < #define HAVE__SYSTEM_CONFIGURATION 1
12092 < _ACEOF
10296 > $as_echo "#define HAVE__SYSTEM_CONFIGURATION 1" >>confdefs.h
10297  
10298   else
10299 <  $as_echo "$as_me: failed program was:" >&5
12096 < sed 's/^/| /' conftest.$ac_ext >&5
12097 <
12098 <        { $as_echo "$as_me:$LINENO: result: no" >&5
10299 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
10300   $as_echo "no" >&6; }
10301   fi
12101 –
10302   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10303  
10304  
# Line 12161 | Line 10361 | if test "$ac_test_FFLAGS" != "set"; then
10361    fi
10362  
10363  
10364 < { $as_echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
10364 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${FC} accepts ${FCFLAGS}" >&5
10365   $as_echo_n "checking whether ${FC} accepts ${FCFLAGS}... " >&6; }
10366 < if test "${ac_guessed_f90flags+set}" = set; then
10366 > if test "${ac_cv_ac_cv_guessed_f90flags+set}" = set; then :
10367    $as_echo_n "(cached) " >&6
10368   else
10369  
# Line 12176 | Line 10376 | ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCE
10376   echo 'program main' > conftest.$ac_ext
10377   echo 'end program main' >> conftest.$ac_ext
10378   ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
10379 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
10379 > if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
10380    (eval $ac_compile) 2>&5
10381    ac_status=$?
10382 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10383 <  (exit $ac_status); }; then
10384 <        ac_guessed_f90flags=yes
10382 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10383 >  test $ac_status = 0; }; then
10384 >        ac_cv_ac_cv_guessed_f90flags=yes
10385   else
10386 <        ac_guessed_f90flags=no
10386 >        ac_cv_ac_cv_guessed_f90flags=no
10387   fi
10388   rm -f conftest*
10389   ac_ext=c
# Line 12194 | Line 10394 | fi
10394  
10395  
10396   fi
10397 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
10398 < $as_echo "$ac_guessed_f90flags" >&6; }
10399 < if test "$ac_guessed_f90flags" = yes; then
10397 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_f90flags" >&5
10398 > $as_echo "$ac_cv_ac_cv_guessed_f90flags" >&6; }
10399 > if test "$ac_cv_ac_cv_guessed_f90flags" = yes; then
10400          :
10401  
10402   else
# Line 12222 | Line 10422 | fi
10422  
10423  
10424  
10425 < { $as_echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
10425 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU cc" >&5
10426   $as_echo_n "checking whether we are *really* using GNU cc... " >&6; }
10427 < if test "${ac_cv_prog_really_gcc+set}" = set; then
10427 > if test "${ac_cv_prog_really_gcc+set}" = set; then :
10428    $as_echo_n "(cached) " >&6
10429   else
10430  
# Line 12238 | Line 10438 | if { ac_try='${CC-cc} -E conftest.c'
10438   #endif
10439   EOF
10440   if { ac_try='${CC-cc} -E conftest.c'
10441 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10441 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
10442    (eval $ac_try) 2>&5
10443    ac_status=$?
10444 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10445 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
10444 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10445 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
10446    ac_cv_prog_really_gcc=yes
10447   else
10448    ac_cv_prog_really_gcc=no
10449   fi
10450  
10451   fi
10452 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
10452 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gcc" >&5
10453   $as_echo "$ac_cv_prog_really_gcc" >&6; }
10454   if test "$ac_cv_prog_really_gcc" = yes; then
10455          :
# Line 12327 | Line 10527 | if test "$ac_test_CFLAGS" != "set"; then
10527  
10528  
10529  
10530 < { $as_echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
10530 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts ${CFLAGS}" >&5
10531   $as_echo_n "checking whether ${CC} accepts ${CFLAGS}... " >&6; }
10532 < if test "${ac_guessed_cflags+set}" = set; then
10532 > if test "${ac_cv_ac_cv_guessed_cflags+set}" = set; then :
10533    $as_echo_n "(cached) " >&6
10534   else
10535    echo 'void f(){}' > conftest.c
10536   if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
10537 <        ac_guessed_cflags=yes
10537 >        ac_cv_ac_cv_guessed_cflags=yes
10538   else
10539 <        ac_guessed_cflags=no
10539 >        ac_cv_ac_cv_guessed_cflags=no
10540   fi
10541   rm -f conftest*
10542  
10543   fi
10544 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
10545 < $as_echo "$ac_guessed_cflags" >&6; }
10546 < if test "$ac_guessed_cflags" = yes; then
10544 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cflags" >&5
10545 > $as_echo "$ac_cv_ac_cv_guessed_cflags" >&6; }
10546 > if test "$ac_cv_ac_cv_guessed_cflags" = yes; then
10547          :
10548  
10549   else
# Line 12369 | Line 10569 | fi
10569  
10570  
10571  
10572 < { $as_echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
10572 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU c++" >&5
10573   $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
10574 < if test "${ac_cv_prog_really_gxx+set}" = set; then
10574 > if test "${ac_cv_prog_really_gxx+set}" = set; then :
10575    $as_echo_n "(cached) " >&6
10576   else
10577  
# Line 12385 | Line 10585 | if { ac_try='${CXX-c++} -E conftest.cpp'
10585   #endif
10586   EOF
10587   if { ac_try='${CXX-c++} -E conftest.cpp'
10588 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
10588 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
10589    (eval $ac_try) 2>&5
10590    ac_status=$?
10591 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10592 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
10591 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
10592 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
10593    ac_cv_prog_really_gxx=yes
10594   else
10595    ac_cv_prog_really_gxx=no
10596   fi
10597  
10598   fi
10599 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
10599 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gxx" >&5
10600   $as_echo "$ac_cv_prog_really_gxx" >&6; }
10601   if test "$ac_cv_prog_really_gxx" = yes; then
10602          :
# Line 12465 | Line 10665 | if test "$ac_test_CXXFLAGS" != "set"; then
10665  
10666  
10667  
10668 < { $as_echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
10668 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
10669   $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
10670 < if test "${ac_guessed_cxxflags+set}" = set; then
10670 > if test "${ac_cv_ac_cv_guessed_cxxflags+set}" = set; then :
10671    $as_echo_n "(cached) " >&6
10672   else
10673    echo 'void f(){}' > conftest.cpp
10674   if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
10675 <        ac_guessed_cxxflags=yes
10675 >        ac_cv_ac_cv_guessed_cxxflags=yes
10676   else
10677 <        ac_guessed_cxxflags=no
10677 >        ac_cv_ac_cv_guessed_cxxflags=no
10678   fi
10679   rm -f conftest*
10680  
10681   fi
10682 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
10683 < $as_echo "$ac_guessed_cxxflags" >&6; }
10684 < if test "$ac_guessed_cxxflags" = yes; then
10682 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cxxflags" >&5
10683 > $as_echo "$ac_cv_ac_cv_guessed_cxxflags" >&6; }
10684 > if test "$ac_cv_ac_cv_guessed_cxxflags" = yes; then
10685          :
10686  
10687   else
# Line 12508 | Line 10708 | acx_cgal_found=no
10708   acx_cgal_found=no
10709  
10710   # Check whether --with-cgalmakefile was given.
10711 < if test "${with_cgalmakefile+set}" = set; then
10711 > if test "${with_cgalmakefile+set}" = set; then :
10712    withval=$with_cgalmakefile;
10713   fi
10714  
# Line 12520 | Line 10720 | if test "$acx_cgal_found" == no; then
10720   esac
10721  
10722   if test "$acx_cgal_found" == no; then
10723 <    { $as_echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
10723 >    { $as_echo "$as_me:${as_lineno-$LINENO}: checking CGAL_MAKEFILE" >&5
10724   $as_echo_n "checking CGAL_MAKEFILE... " >&6; }
10725  
10726      if test \! -z "$CGAL_MAKEFILE"; then
# Line 12529 | Line 10729 | cat > $tname << _ACEOF
10729              tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
10730  
10731   cat > $tname << _ACEOF
10732 < include $CGAL_MAKEFILE
12533 <
12534 < cppflags:
12535 <        @echo \$(CGAL_CXXFLAGS)
12536 <
12537 < cxxflags:
12538 <        @echo
12539 < ldflags:
12540 <        @echo \$(CGAL_LDFLAGS)
12541 < _ACEOF
12542 <            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
12543 <            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
12544 <            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
12545 <            for i in $CGAL_LDFLAGST; do
12546 <                if test `echo $i| grep -c ^-l`; then
12547 <                    CGAL_LIBS="$CGAL_LIBS $i"
12548 <                else
12549 <                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
12550 <                fi
12551 <            done
12552 <            rm -f $tname
12553 <            { $as_echo "$as_me:$LINENO: result: yes" >&5
12554 < $as_echo "yes" >&6; }
12555 <            acx_cgal_found=yes
12556 <                                   else
12557 <            { $as_echo "$as_me:$LINENO: result: invalid" >&5
12558 < $as_echo "invalid" >&6; }
12559 <            { { $as_echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
12560 < $as_echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
12561 <   { (exit 1); exit 1; }; }
12562 <        fi
12563 <    else
12564 <        { $as_echo "$as_me:$LINENO: result: not defined" >&5
12565 < $as_echo "not defined" >&6; }
12566 <    fi
12567 < fi
12568 <
12569 < if test "$acx_cgal_found" == no; then
12570 <        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12571 <  { $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12572 < $as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12573 < if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12574 <  $as_echo_n "(cached) " >&6
12575 < fi
12576 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12577 < $as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12578 < else
12579 <  # Is the header compilable?
12580 < { $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
12581 < $as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... " >&6; }
12582 < cat >conftest.$ac_ext <<_ACEOF
12583 < /* confdefs.h.  */
12584 < _ACEOF
12585 < cat confdefs.h >>conftest.$ac_ext
12586 < cat >>conftest.$ac_ext <<_ACEOF
12587 < /* end confdefs.h.  */
12588 < $ac_includes_default
12589 < #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12590 < _ACEOF
12591 < rm -f conftest.$ac_objext
12592 < if { (ac_try="$ac_compile"
12593 < case "(($ac_try" in
12594 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12595 <  *) ac_try_echo=$ac_try;;
12596 < esac
12597 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12598 < $as_echo "$ac_try_echo") >&5
12599 <  (eval "$ac_compile") 2>conftest.er1
12600 <  ac_status=$?
12601 <  grep -v '^ *+' conftest.er1 >conftest.err
12602 <  rm -f conftest.er1
12603 <  cat conftest.err >&5
12604 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12605 <  (exit $ac_status); } && {
12606 <         test -z "$ac_c_werror_flag" ||
12607 <         test ! -s conftest.err
12608 <       } && test -s conftest.$ac_objext; then
12609 <  ac_header_compiler=yes
12610 < else
12611 <  $as_echo "$as_me: failed program was:" >&5
12612 < sed 's/^/| /' conftest.$ac_ext >&5
12613 <
12614 <        ac_header_compiler=no
12615 < fi
12616 <
12617 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12618 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12619 < $as_echo "$ac_header_compiler" >&6; }
12620 <
12621 < # Is the header present?
12622 < { $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
12623 < $as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... " >&6; }
12624 < cat >conftest.$ac_ext <<_ACEOF
12625 < /* confdefs.h.  */
12626 < _ACEOF
12627 < cat confdefs.h >>conftest.$ac_ext
12628 < cat >>conftest.$ac_ext <<_ACEOF
12629 < /* end confdefs.h.  */
12630 < #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12631 < _ACEOF
12632 < if { (ac_try="$ac_cpp conftest.$ac_ext"
12633 < case "(($ac_try" in
12634 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12635 <  *) ac_try_echo=$ac_try;;
12636 < esac
12637 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12638 < $as_echo "$ac_try_echo") >&5
12639 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
12640 <  ac_status=$?
12641 <  grep -v '^ *+' conftest.er1 >conftest.err
12642 <  rm -f conftest.er1
12643 <  cat conftest.err >&5
12644 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12645 <  (exit $ac_status); } >/dev/null && {
12646 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12647 <         test ! -s conftest.err
12648 <       }; then
12649 <  ac_header_preproc=yes
12650 < else
12651 <  $as_echo "$as_me: failed program was:" >&5
12652 < sed 's/^/| /' conftest.$ac_ext >&5
10732 > include $CGAL_MAKEFILE
10733  
10734 <  ac_header_preproc=no
10735 < fi
10734 > cppflags:
10735 >        @echo \$(CGAL_CXXFLAGS)
10736  
10737 < rm -f conftest.err conftest.$ac_ext
10738 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10739 < $as_echo "$ac_header_preproc" >&6; }
10740 <
10741 < # So?  What about this header?
10742 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10743 <  yes:no: )
10744 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
10745 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
10746 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
10747 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
10748 <    ac_header_preproc=yes
10749 <    ;;
10750 <  no:yes:* )
10751 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
10752 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
10753 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
10754 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
10755 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
10756 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
10757 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
10758 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
10759 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
10760 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
10761 <    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
10762 < $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
10763 <    ( cat <<\_ASBOX
10764 < ## ------------------------------ ##
12685 < ## Report this to gezelter@nd.edu ##
12686 < ## ------------------------------ ##
12687 < _ASBOX
12688 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
12689 <    ;;
12690 < esac
12691 < { $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12692 < $as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12693 < if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12694 <  $as_echo_n "(cached) " >&6
12695 < else
12696 <  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
10737 > cxxflags:
10738 >        @echo
10739 > ldflags:
10740 >        @echo \$(CGAL_LDFLAGS)
10741 > _ACEOF
10742 >            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
10743 >            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
10744 >            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
10745 >            for i in $CGAL_LDFLAGST; do
10746 >                if test `echo $i| grep -c ^-l`; then
10747 >                    CGAL_LIBS="$CGAL_LIBS $i"
10748 >                else
10749 >                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
10750 >                fi
10751 >            done
10752 >            rm -f $tname
10753 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
10754 > $as_echo "yes" >&6; }
10755 >            acx_cgal_found=yes
10756 >                                   else
10757 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: invalid" >&5
10758 > $as_echo "invalid" >&6; }
10759 >            as_fn_error "CGAL_MAKEFILE defined, but the makefile does not exist." "$LINENO" 5
10760 >        fi
10761 >    else
10762 >        { $as_echo "$as_me:${as_lineno-$LINENO}: result: not defined" >&5
10763 > $as_echo "not defined" >&6; }
10764 >    fi
10765   fi
12698 – { $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12699 – $as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
10766  
10767 < fi
10768 < if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
10767 > if test "$acx_cgal_found" == no; then
10768 >        ac_fn_c_check_header_mongrel "$LINENO" "CGAL/Exact_predicates_inexact_constructions_kernel.h" "ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" "$ac_includes_default"
10769 > if test "x$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" = x""yes; then :
10770    cgal_have_header=yes
10771   else
10772    cgal_have_header=no
# Line 12707 | Line 10774 | fi
10774  
10775  
10776          if test "$cgal_have_header" == yes; then
10777 <                { $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
10777 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lCGAL" >&5
10778   $as_echo_n "checking for main in -lCGAL... " >&6; }
10779 < if test "${ac_cv_lib_CGAL_main+set}" = set; then
10779 > if test "${ac_cv_lib_CGAL_main+set}" = set; then :
10780    $as_echo_n "(cached) " >&6
10781   else
10782    ac_check_lib_save_LIBS=$LIBS
10783   LIBS="-lCGAL  $LIBS"
10784 < cat >conftest.$ac_ext <<_ACEOF
12718 < /* confdefs.h.  */
12719 < _ACEOF
12720 < cat confdefs.h >>conftest.$ac_ext
12721 < cat >>conftest.$ac_ext <<_ACEOF
10784 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10785   /* end confdefs.h.  */
10786  
10787  
# Line 12738 | Line 10801 | _ACEOF
10801    return 0;
10802   }
10803   _ACEOF
10804 < rm -f conftest.$ac_objext conftest$ac_exeext
12742 < if { (ac_try="$ac_link"
12743 < case "(($ac_try" in
12744 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12745 <  *) ac_try_echo=$ac_try;;
12746 < esac
12747 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12748 < $as_echo "$ac_try_echo") >&5
12749 <  (eval "$ac_link") 2>conftest.er1
12750 <  ac_status=$?
12751 <  grep -v '^ *+' conftest.er1 >conftest.err
12752 <  rm -f conftest.er1
12753 <  cat conftest.err >&5
12754 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12755 <  (exit $ac_status); } && {
12756 <         test -z "$ac_c_werror_flag" ||
12757 <         test ! -s conftest.err
12758 <       } && test -s conftest$ac_exeext && {
12759 <         test "$cross_compiling" = yes ||
12760 <         $as_test_x conftest$ac_exeext
12761 <       }; then
10804 > if ac_fn_c_try_link "$LINENO"; then :
10805    ac_cv_lib_CGAL_main=yes
10806   else
10807 <  $as_echo "$as_me: failed program was:" >&5
12765 < sed 's/^/| /' conftest.$ac_ext >&5
12766 <
12767 <        ac_cv_lib_CGAL_main=no
10807 >  ac_cv_lib_CGAL_main=no
10808   fi
10809 <
10810 < rm -rf conftest.dSYM
12771 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12772 <      conftest$ac_exeext conftest.$ac_ext
10809 > rm -f core conftest.err conftest.$ac_objext \
10810 >    conftest$ac_exeext conftest.$ac_ext
10811   LIBS=$ac_check_lib_save_LIBS
10812   fi
10813 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
10813 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_CGAL_main" >&5
10814   $as_echo "$ac_cv_lib_CGAL_main" >&6; }
10815 < if test $ac_cv_lib_CGAL_main = yes; then
10815 > if test "x$ac_cv_lib_CGAL_main" = x""yes; then :
10816    cgal_have_lib=yes
10817   else
10818    cgal_have_lib=no
# Line 12782 | Line 10820 | fi
10820  
10821                  if test "$cgal_have_lib" == no; then
10822                          save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
10823 <                        { $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
10823 >                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lCGAL" >&5
10824   $as_echo_n "checking for main in -lCGAL... " >&6; }
10825 < if test "${ac_cv_lib_CGAL_main+set}" = set; then
10825 > if test "${ac_cv_lib_CGAL_main+set}" = set; then :
10826    $as_echo_n "(cached) " >&6
10827   else
10828    ac_check_lib_save_LIBS=$LIBS
10829   LIBS="-lCGAL  $LIBS"
10830 < cat >conftest.$ac_ext <<_ACEOF
12793 < /* confdefs.h.  */
12794 < _ACEOF
12795 < cat confdefs.h >>conftest.$ac_ext
12796 < cat >>conftest.$ac_ext <<_ACEOF
10830 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10831   /* end confdefs.h.  */
10832  
10833  
# Line 12813 | Line 10847 | _ACEOF
10847    return 0;
10848   }
10849   _ACEOF
10850 < rm -f conftest.$ac_objext conftest$ac_exeext
12817 < if { (ac_try="$ac_link"
12818 < case "(($ac_try" in
12819 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12820 <  *) ac_try_echo=$ac_try;;
12821 < esac
12822 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12823 < $as_echo "$ac_try_echo") >&5
12824 <  (eval "$ac_link") 2>conftest.er1
12825 <  ac_status=$?
12826 <  grep -v '^ *+' conftest.er1 >conftest.err
12827 <  rm -f conftest.er1
12828 <  cat conftest.err >&5
12829 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12830 <  (exit $ac_status); } && {
12831 <         test -z "$ac_c_werror_flag" ||
12832 <         test ! -s conftest.err
12833 <       } && test -s conftest$ac_exeext && {
12834 <         test "$cross_compiling" = yes ||
12835 <         $as_test_x conftest$ac_exeext
12836 <       }; then
10850 > if ac_fn_c_try_link "$LINENO"; then :
10851    ac_cv_lib_CGAL_main=yes
10852   else
10853 <  $as_echo "$as_me: failed program was:" >&5
12840 < sed 's/^/| /' conftest.$ac_ext >&5
12841 <
12842 <        ac_cv_lib_CGAL_main=no
10853 >  ac_cv_lib_CGAL_main=no
10854   fi
10855 <
10856 < rm -rf conftest.dSYM
12846 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12847 <      conftest$ac_exeext conftest.$ac_ext
10855 > rm -f core conftest.err conftest.$ac_objext \
10856 >    conftest$ac_exeext conftest.$ac_ext
10857   LIBS=$ac_check_lib_save_LIBS
10858   fi
10859 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
10859 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_CGAL_main" >&5
10860   $as_echo "$ac_cv_lib_CGAL_main" >&6; }
10861 < if test $ac_cv_lib_CGAL_main = yes; then
10861 > if test "x$ac_cv_lib_CGAL_main" = x""yes; then :
10862    CGAL_LIBS="-lCGAL -lgmp -lmpfr"
10863                                                    cgal_have_lib=yes
10864   else
# Line 12859 | Line 10868 | fi
10868                          LIBS="$save_LIBS"
10869                  else
10870                          CGAL_LIBS="-lCGAL"
10871 <                        { $as_echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
10871 >                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lmpfr" >&5
10872   $as_echo_n "checking for main in -lmpfr... " >&6; }
10873 < if test "${ac_cv_lib_mpfr_main+set}" = set; then
10873 > if test "${ac_cv_lib_mpfr_main+set}" = set; then :
10874    $as_echo_n "(cached) " >&6
10875   else
10876    ac_check_lib_save_LIBS=$LIBS
10877   LIBS="-lmpfr  $LIBS"
10878 < cat >conftest.$ac_ext <<_ACEOF
12870 < /* confdefs.h.  */
12871 < _ACEOF
12872 < cat confdefs.h >>conftest.$ac_ext
12873 < cat >>conftest.$ac_ext <<_ACEOF
10878 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10879   /* end confdefs.h.  */
10880  
10881  
# Line 12890 | Line 10895 | _ACEOF
10895    return 0;
10896   }
10897   _ACEOF
10898 < rm -f conftest.$ac_objext conftest$ac_exeext
12894 < if { (ac_try="$ac_link"
12895 < case "(($ac_try" in
12896 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12897 <  *) ac_try_echo=$ac_try;;
12898 < esac
12899 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12900 < $as_echo "$ac_try_echo") >&5
12901 <  (eval "$ac_link") 2>conftest.er1
12902 <  ac_status=$?
12903 <  grep -v '^ *+' conftest.er1 >conftest.err
12904 <  rm -f conftest.er1
12905 <  cat conftest.err >&5
12906 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12907 <  (exit $ac_status); } && {
12908 <         test -z "$ac_c_werror_flag" ||
12909 <         test ! -s conftest.err
12910 <       } && test -s conftest$ac_exeext && {
12911 <         test "$cross_compiling" = yes ||
12912 <         $as_test_x conftest$ac_exeext
12913 <       }; then
10898 > if ac_fn_c_try_link "$LINENO"; then :
10899    ac_cv_lib_mpfr_main=yes
10900   else
10901 <  $as_echo "$as_me: failed program was:" >&5
12917 < sed 's/^/| /' conftest.$ac_ext >&5
12918 <
12919 <        ac_cv_lib_mpfr_main=no
10901 >  ac_cv_lib_mpfr_main=no
10902   fi
10903 <
10904 < rm -rf conftest.dSYM
12923 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12924 <      conftest$ac_exeext conftest.$ac_ext
10903 > rm -f core conftest.err conftest.$ac_objext \
10904 >    conftest$ac_exeext conftest.$ac_ext
10905   LIBS=$ac_check_lib_save_LIBS
10906   fi
10907 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
10907 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpfr_main" >&5
10908   $as_echo "$ac_cv_lib_mpfr_main" >&6; }
10909 < if test $ac_cv_lib_mpfr_main = yes; then
10909 > if test "x$ac_cv_lib_mpfr_main" = x""yes; then :
10910    CGAL_LIBS="$CGAL_LIBS -lmpfr"
10911   fi
10912  
10913 <                        { $as_echo "$as_me:$LINENO: checking for main in -lgmp" >&5
10913 >                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lgmp" >&5
10914   $as_echo_n "checking for main in -lgmp... " >&6; }
10915 < if test "${ac_cv_lib_gmp_main+set}" = set; then
10915 > if test "${ac_cv_lib_gmp_main+set}" = set; then :
10916    $as_echo_n "(cached) " >&6
10917   else
10918    ac_check_lib_save_LIBS=$LIBS
10919   LIBS="-lgmp  $LIBS"
10920 < cat >conftest.$ac_ext <<_ACEOF
12941 < /* confdefs.h.  */
12942 < _ACEOF
12943 < cat confdefs.h >>conftest.$ac_ext
12944 < cat >>conftest.$ac_ext <<_ACEOF
10920 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10921   /* end confdefs.h.  */
10922  
10923  
# Line 12961 | Line 10937 | _ACEOF
10937    return 0;
10938   }
10939   _ACEOF
10940 < rm -f conftest.$ac_objext conftest$ac_exeext
12965 < if { (ac_try="$ac_link"
12966 < case "(($ac_try" in
12967 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12968 <  *) ac_try_echo=$ac_try;;
12969 < esac
12970 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12971 < $as_echo "$ac_try_echo") >&5
12972 <  (eval "$ac_link") 2>conftest.er1
12973 <  ac_status=$?
12974 <  grep -v '^ *+' conftest.er1 >conftest.err
12975 <  rm -f conftest.er1
12976 <  cat conftest.err >&5
12977 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12978 <  (exit $ac_status); } && {
12979 <         test -z "$ac_c_werror_flag" ||
12980 <         test ! -s conftest.err
12981 <       } && test -s conftest$ac_exeext && {
12982 <         test "$cross_compiling" = yes ||
12983 <         $as_test_x conftest$ac_exeext
12984 <       }; then
10940 > if ac_fn_c_try_link "$LINENO"; then :
10941    ac_cv_lib_gmp_main=yes
10942   else
10943 <  $as_echo "$as_me: failed program was:" >&5
12988 < sed 's/^/| /' conftest.$ac_ext >&5
12989 <
12990 <        ac_cv_lib_gmp_main=no
10943 >  ac_cv_lib_gmp_main=no
10944   fi
10945 <
10946 < rm -rf conftest.dSYM
12994 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12995 <      conftest$ac_exeext conftest.$ac_ext
10945 > rm -f core conftest.err conftest.$ac_objext \
10946 >    conftest$ac_exeext conftest.$ac_ext
10947   LIBS=$ac_check_lib_save_LIBS
10948   fi
10949 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
10949 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gmp_main" >&5
10950   $as_echo "$ac_cv_lib_gmp_main" >&6; }
10951 < if test $ac_cv_lib_gmp_main = yes; then
10951 > if test "x$ac_cv_lib_gmp_main" = x""yes; then :
10952    CGAL_LIBS="$CGAL_LIBS -lgmp"
10953   fi
10954  
10955 <                        { $as_echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
10955 >                        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lgmpxx" >&5
10956   $as_echo_n "checking for main in -lgmpxx... " >&6; }
10957 < if test "${ac_cv_lib_gmpxx_main+set}" = set; then
10957 > if test "${ac_cv_lib_gmpxx_main+set}" = set; then :
10958    $as_echo_n "(cached) " >&6
10959   else
10960    ac_check_lib_save_LIBS=$LIBS
10961   LIBS="-lgmpxx  $LIBS"
10962 < cat >conftest.$ac_ext <<_ACEOF
13012 < /* confdefs.h.  */
13013 < _ACEOF
13014 < cat confdefs.h >>conftest.$ac_ext
13015 < cat >>conftest.$ac_ext <<_ACEOF
10962 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
10963   /* end confdefs.h.  */
10964  
10965  
# Line 13032 | Line 10979 | _ACEOF
10979    return 0;
10980   }
10981   _ACEOF
10982 < rm -f conftest.$ac_objext conftest$ac_exeext
13036 < if { (ac_try="$ac_link"
13037 < case "(($ac_try" in
13038 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13039 <  *) ac_try_echo=$ac_try;;
13040 < esac
13041 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13042 < $as_echo "$ac_try_echo") >&5
13043 <  (eval "$ac_link") 2>conftest.er1
13044 <  ac_status=$?
13045 <  grep -v '^ *+' conftest.er1 >conftest.err
13046 <  rm -f conftest.er1
13047 <  cat conftest.err >&5
13048 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13049 <  (exit $ac_status); } && {
13050 <         test -z "$ac_c_werror_flag" ||
13051 <         test ! -s conftest.err
13052 <       } && test -s conftest$ac_exeext && {
13053 <         test "$cross_compiling" = yes ||
13054 <         $as_test_x conftest$ac_exeext
13055 <       }; then
10982 > if ac_fn_c_try_link "$LINENO"; then :
10983    ac_cv_lib_gmpxx_main=yes
10984   else
10985 <  $as_echo "$as_me: failed program was:" >&5
13059 < sed 's/^/| /' conftest.$ac_ext >&5
13060 <
13061 <        ac_cv_lib_gmpxx_main=no
10985 >  ac_cv_lib_gmpxx_main=no
10986   fi
10987 <
10988 < rm -rf conftest.dSYM
13065 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13066 <      conftest$ac_exeext conftest.$ac_ext
10987 > rm -f core conftest.err conftest.$ac_objext \
10988 >    conftest$ac_exeext conftest.$ac_ext
10989   LIBS=$ac_check_lib_save_LIBS
10990   fi
10991 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
10991 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gmpxx_main" >&5
10992   $as_echo "$ac_cv_lib_gmpxx_main" >&6; }
10993 < if test $ac_cv_lib_gmpxx_main = yes; then
10993 > if test "x$ac_cv_lib_gmpxx_main" = x""yes; then :
10994    CGAL_LIBS="$CGAL_LIBS -lgmpxx"
10995   fi
10996  
# Line 13079 | Line 11001 | fi
11001                  fi
11002          fi
11003          if test "$acx_cgal_found" == yes; then
11004 <                { $as_echo "$as_me:$LINENO: checking for main in -lCore" >&5
11004 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lCore" >&5
11005   $as_echo_n "checking for main in -lCore... " >&6; }
11006 < if test "${ac_cv_lib_Core_main+set}" = set; then
11006 > if test "${ac_cv_lib_Core_main+set}" = set; then :
11007    $as_echo_n "(cached) " >&6
11008   else
11009    ac_check_lib_save_LIBS=$LIBS
11010   LIBS="-lCore  $LIBS"
11011 < cat >conftest.$ac_ext <<_ACEOF
13090 < /* confdefs.h.  */
13091 < _ACEOF
13092 < cat confdefs.h >>conftest.$ac_ext
13093 < cat >>conftest.$ac_ext <<_ACEOF
11011 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
11012   /* end confdefs.h.  */
11013  
11014  
# Line 13110 | Line 11028 | _ACEOF
11028    return 0;
11029   }
11030   _ACEOF
11031 < rm -f conftest.$ac_objext conftest$ac_exeext
13114 < if { (ac_try="$ac_link"
13115 < case "(($ac_try" in
13116 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13117 <  *) ac_try_echo=$ac_try;;
13118 < esac
13119 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13120 < $as_echo "$ac_try_echo") >&5
13121 <  (eval "$ac_link") 2>conftest.er1
13122 <  ac_status=$?
13123 <  grep -v '^ *+' conftest.er1 >conftest.err
13124 <  rm -f conftest.er1
13125 <  cat conftest.err >&5
13126 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13127 <  (exit $ac_status); } && {
13128 <         test -z "$ac_c_werror_flag" ||
13129 <         test ! -s conftest.err
13130 <       } && test -s conftest$ac_exeext && {
13131 <         test "$cross_compiling" = yes ||
13132 <         $as_test_x conftest$ac_exeext
13133 <       }; then
11031 > if ac_fn_c_try_link "$LINENO"; then :
11032    ac_cv_lib_Core_main=yes
11033   else
11034 <  $as_echo "$as_me: failed program was:" >&5
13137 < sed 's/^/| /' conftest.$ac_ext >&5
13138 <
13139 <        ac_cv_lib_Core_main=no
11034 >  ac_cv_lib_Core_main=no
11035   fi
11036 <
11037 < rm -rf conftest.dSYM
13143 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13144 <      conftest$ac_exeext conftest.$ac_ext
11036 > rm -f core conftest.err conftest.$ac_objext \
11037 >    conftest$ac_exeext conftest.$ac_ext
11038   LIBS=$ac_check_lib_save_LIBS
11039   fi
11040 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
11040 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_Core_main" >&5
11041   $as_echo "$ac_cv_lib_Core_main" >&6; }
11042 < if test $ac_cv_lib_Core_main = yes; then
11042 > if test "x$ac_cv_lib_Core_main" = x""yes; then :
11043    CGAL_LIBS="$CGAL_LIBS -lCore"
11044   fi
11045  
# Line 13155 | Line 11048 | fi
11048  
11049  
11050  
11051 < { $as_echo "$as_me:$LINENO: checking CGAL" >&5
11051 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking CGAL" >&5
11052   $as_echo_n "checking CGAL... " >&6; }
11053  
11054  
# Line 13163 | Line 11056 | if test "$acx_cgal_found" == yes; then
11056  
11057  
11058   if test "$acx_cgal_found" == yes; then
11059 <        { $as_echo "$as_me:$LINENO: result: yes" >&5
11059 >        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
11060   $as_echo "yes" >&6; }
11061  
11062   else
11063 <        { $as_echo "$as_me:$LINENO: result: no" >&5
11063 >        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11064   $as_echo "no" >&6; }
11065  
11066   fi
# Line 13175 | Line 11068 | if test "$acx_cgal_found" == yes; then
11068   if test "$acx_cgal_found" == yes; then
11069          USE_CGAL=yes
11070  
11071 < cat >>confdefs.h <<\_ACEOF
13179 < #define HAVE_CGAL 1
13180 < _ACEOF
11071 > $as_echo "#define HAVE_CGAL 1" >>confdefs.h
11072  
11073  
11074  
# Line 13189 | Line 11080 | fi
11080  
11081  
11082   # Check whether --enable-doxygen was given.
11083 < if test "${enable_doxygen+set}" = set; then
11083 > if test "${enable_doxygen+set}" = set; then :
11084    enableval=$enable_doxygen;
11085   fi
11086  
11087   # Check whether --enable-dot was given.
11088 < if test "${enable_dot+set}" = set; then
11088 > if test "${enable_dot+set}" = set; then :
11089    enableval=$enable_dot;
11090   fi
11091  
11092   # Check whether --enable-html-docs was given.
11093 < if test "${enable_html_docs+set}" = set; then
11093 > if test "${enable_html_docs+set}" = set; then :
11094    enableval=$enable_html_docs;
11095   else
11096     enable_html_docs=yes
11097   fi
11098  
11099   # Check whether --enable-latex-docs was given.
11100 < if test "${enable_latex_docs+set}" = set; then
11100 > if test "${enable_latex_docs+set}" = set; then :
11101    enableval=$enable_latex_docs;
11102   else
11103     enable_latex_docs=no
# Line 13217 | Line 11108 | set dummy doxygen; ac_word=$2
11108   else
11109          # Extract the first word of "doxygen", so it can be a program name with args.
11110   set dummy doxygen; ac_word=$2
11111 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
11111 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11112   $as_echo_n "checking for $ac_word... " >&6; }
11113 < if test "${ac_cv_path_DOXYGEN+set}" = set; then
11113 > if test "${ac_cv_path_DOXYGEN+set}" = set; then :
11114    $as_echo_n "(cached) " >&6
11115   else
11116    case $DOXYGEN in
# Line 13232 | Line 11123 | do
11123   do
11124    IFS=$as_save_IFS
11125    test -z "$as_dir" && as_dir=.
11126 <  for ac_exec_ext in '' $ac_executable_extensions; do
11126 >    for ac_exec_ext in '' $ac_executable_extensions; do
11127    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
11128      ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
11129 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11129 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11130      break 2
11131    fi
11132   done
11133 < done
11133 >  done
11134   IFS=$as_save_IFS
11135  
11136    ;;
# Line 13247 | Line 11138 | if test -n "$DOXYGEN"; then
11138   fi
11139   DOXYGEN=$ac_cv_path_DOXYGEN
11140   if test -n "$DOXYGEN"; then
11141 <  { $as_echo "$as_me:$LINENO: result: $DOXYGEN" >&5
11141 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOXYGEN" >&5
11142   $as_echo "$DOXYGEN" >&6; }
11143   else
11144 <  { $as_echo "$as_me:$LINENO: result: no" >&5
11144 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11145   $as_echo "no" >&6; }
11146   fi
11147  
11148  
11149          if test "x$DOXYGEN" = x; then
11150                  if test "x$enable_doxygen" = xyes; then
11151 <                        { { $as_echo "$as_me:$LINENO: error: could not find doxygen" >&5
13261 < $as_echo "$as_me: error: could not find doxygen" >&2;}
13262 <   { (exit 1); exit 1; }; }
11151 >                        as_fn_error "could not find doxygen" "$LINENO" 5
11152                  fi
11153                  enable_doc=no
11154          else
11155                  enable_doc=yes
11156                  # Extract the first word of "dot", so it can be a program name with args.
11157   set dummy dot; ac_word=$2
11158 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
11158 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
11159   $as_echo_n "checking for $ac_word... " >&6; }
11160 < if test "${ac_cv_path_DOT+set}" = set; then
11160 > if test "${ac_cv_path_DOT+set}" = set; then :
11161    $as_echo_n "(cached) " >&6
11162   else
11163    case $DOT in
# Line 13281 | Line 11170 | do
11170   do
11171    IFS=$as_save_IFS
11172    test -z "$as_dir" && as_dir=.
11173 <  for ac_exec_ext in '' $ac_executable_extensions; do
11173 >    for ac_exec_ext in '' $ac_executable_extensions; do
11174    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
11175      ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
11176 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11176 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
11177      break 2
11178    fi
11179   done
11180 < done
11180 >  done
11181   IFS=$as_save_IFS
11182  
11183    ;;
# Line 13296 | Line 11185 | if test -n "$DOT"; then
11185   fi
11186   DOT=$ac_cv_path_DOT
11187   if test -n "$DOT"; then
11188 <  { $as_echo "$as_me:$LINENO: result: $DOT" >&5
11188 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
11189   $as_echo "$DOT" >&6; }
11190   else
11191 <  { $as_echo "$as_me:$LINENO: result: no" >&5
11191 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
11192   $as_echo "no" >&6; }
11193   fi
11194  
# Line 13316 | Line 11205 | if test x$DOT = x; then
11205  
11206   if test x$DOT = x; then
11207          if test "x$enable_dot" = xyes; then
11208 <                { { $as_echo "$as_me:$LINENO: error: could not find dot" >&5
13320 < $as_echo "$as_me: error: could not find dot" >&2;}
13321 <   { (exit 1); exit 1; }; }
11208 >                as_fn_error "could not find dot" "$LINENO" 5
11209          fi
11210          enable_dot=no
11211   else
# Line 13343 | Line 11230 | fi
11230  
11231  
11232  
11233 < ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/applications/atom2md/Makefile scripts/filepp"
11233 > ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/integrators/Makefile src/applications/atom2md/Makefile scripts/filepp"
11234  
11235  
11236   cat >confcache <<\_ACEOF
# Line 13373 | Line 11260 | _ACEOF
11260      case $ac_val in #(
11261      *${as_nl}*)
11262        case $ac_var in #(
11263 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
11264 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
11263 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
11264 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
11265        esac
11266        case $ac_var in #(
11267        _ | IFS | as_nl) ;; #(
11268        BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
11269 <      *) $as_unset $ac_var ;;
11269 >      *) { eval $ac_var=; unset $ac_var;} ;;
11270        esac ;;
11271      esac
11272    done
# Line 13387 | Line 11274 | $as_echo "$as_me: WARNING: Cache variable $ac_var cont
11274    (set) 2>&1 |
11275      case $as_nl`(ac_space=' '; set) 2>&1` in #(
11276      *${as_nl}ac_space=\ *)
11277 <      # `set' does not quote correctly, so add quotes (double-quote
11278 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
11277 >      # `set' does not quote correctly, so add quotes: double-quote
11278 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
11279        sed -n \
11280          "s/'/'\\\\''/g;
11281            s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
# Line 13411 | Line 11298 | if diff "$cache_file" confcache >/dev/null 2>&1; then
11298   if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
11299    if test -w "$cache_file"; then
11300      test "x$cache_file" != "x/dev/null" &&
11301 <      { $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
11301 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
11302   $as_echo "$as_me: updating cache $cache_file" >&6;}
11303      cat confcache >$cache_file
11304    else
11305 <    { $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
11305 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
11306   $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
11307    fi
11308   fi
# Line 13435 | Line 11322 | for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && conti
11322    ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
11323    # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
11324    #    will be set to the directory where LIBOBJS objects are built.
11325 <  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
11326 <  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
11325 >  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
11326 >  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
11327   done
11328   LIBOBJS=$ac_libobjs
11329  
# Line 13448 | Line 11335 | ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11335   ac_write_fail=0
11336   ac_clean_files_save=$ac_clean_files
11337   ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11338 < { $as_echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11338 > { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
11339   $as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
11340 < cat >$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
11340 > as_write_fail=0
11341 > cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
11342   #! $SHELL
11343   # Generated by $as_me.
11344   # Run this file to recreate the current configuration.
# Line 13460 | Line 11348 | ac_cs_silent=false
11348   debug=false
11349   ac_cs_recheck=false
11350   ac_cs_silent=false
11351 +
11352   SHELL=\${CONFIG_SHELL-$SHELL}
11353 < _ACEOF
11353 > export SHELL
11354 > _ASEOF
11355 > cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
11356 > ## -------------------- ##
11357 > ## M4sh Initialization. ##
11358 > ## -------------------- ##
11359  
13466 – cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
13467 – ## --------------------- ##
13468 – ## M4sh Initialization.  ##
13469 – ## --------------------- ##
13470 –
11360   # Be more Bourne compatible
11361   DUALCASE=1; export DUALCASE # for MKS sh
11362 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11362 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
11363    emulate sh
11364    NULLCMD=:
11365    # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# Line 13478 | Line 11367 | else
11367    alias -g '${1+"$@"}'='"$@"'
11368    setopt NO_GLOB_SUBST
11369   else
11370 <  case `(set -o) 2>/dev/null` in
11371 <  *posix*) set -o posix ;;
11370 >  case `(set -o) 2>/dev/null` in #(
11371 >  *posix*) :
11372 >    set -o posix ;; #(
11373 >  *) :
11374 >     ;;
11375   esac
13484 –
11376   fi
11377  
11378  
13488 –
13489 –
13490 – # PATH needs CR
13491 – # Avoid depending upon Character Ranges.
13492 – as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13493 – as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13494 – as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13495 – as_cr_digits='0123456789'
13496 – as_cr_alnum=$as_cr_Letters$as_cr_digits
13497 –
11379   as_nl='
11380   '
11381   export as_nl
# Line 13502 | Line 11383 | as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
11383   as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
11384   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
11385   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
11386 < if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
11386 > # Prefer a ksh shell builtin over an external printf program on Solaris,
11387 > # but without wasting forks for bash or zsh.
11388 > if test -z "$BASH_VERSION$ZSH_VERSION" \
11389 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
11390 >  as_echo='print -r --'
11391 >  as_echo_n='print -rn --'
11392 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
11393    as_echo='printf %s\n'
11394    as_echo_n='printf %s'
11395   else
# Line 13513 | Line 11400 | else
11400      as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
11401      as_echo_n_body='eval
11402        arg=$1;
11403 <      case $arg in
11403 >      case $arg in #(
11404        *"$as_nl"*)
11405          expr "X$arg" : "X\\(.*\\)$as_nl";
11406          arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
# Line 13536 | Line 11423 | fi
11423    }
11424   fi
11425  
13539 – # Support unset when possible.
13540 – if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13541 –  as_unset=unset
13542 – else
13543 –  as_unset=false
13544 – fi
11426  
13546 –
11427   # IFS
11428   # We need space, tab and new line, in precisely that order.  Quoting is
11429   # there to prevent editors from complaining about space-tab.
# Line 13552 | Line 11432 | IFS=" ""       $as_nl"
11432   IFS=" ""        $as_nl"
11433  
11434   # Find who we are.  Look in the path if we contain no directory separator.
11435 < case $0 in
11435 > case $0 in #((
11436    *[\\/]* ) as_myself=$0 ;;
11437    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11438   for as_dir in $PATH
11439   do
11440    IFS=$as_save_IFS
11441    test -z "$as_dir" && as_dir=.
11442 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11443 < done
11442 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11443 >  done
11444   IFS=$as_save_IFS
11445  
11446       ;;
# Line 13572 | Line 11452 | if test ! -f "$as_myself"; then
11452   fi
11453   if test ! -f "$as_myself"; then
11454    $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
11455 <  { (exit 1); exit 1; }
11455 >  exit 1
11456   fi
11457  
11458 < # Work around bugs in pre-3.0 UWIN ksh.
11459 < for as_var in ENV MAIL MAILPATH
11460 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
11458 > # Unset variables that we do not need and which cause bugs (e.g. in
11459 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
11460 > # suppresses any "Segmentation fault" message there.  '((' could
11461 > # trigger a bug in pdksh 5.2.14.
11462 > for as_var in BASH_ENV ENV MAIL MAILPATH
11463 > do eval test x\${$as_var+set} = xset \
11464 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
11465   done
11466   PS1='$ '
11467   PS2='> '
# Line 13589 | Line 11473 | export LANGUAGE
11473   LANGUAGE=C
11474   export LANGUAGE
11475  
11476 < # Required to use basename.
11476 > # CDPATH.
11477 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
11478 >
11479 >
11480 > # as_fn_error ERROR [LINENO LOG_FD]
11481 > # ---------------------------------
11482 > # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
11483 > # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
11484 > # script with status $?, using 1 if that was 0.
11485 > as_fn_error ()
11486 > {
11487 >  as_status=$?; test $as_status -eq 0 && as_status=1
11488 >  if test "$3"; then
11489 >    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
11490 >    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
11491 >  fi
11492 >  $as_echo "$as_me: error: $1" >&2
11493 >  as_fn_exit $as_status
11494 > } # as_fn_error
11495 >
11496 >
11497 > # as_fn_set_status STATUS
11498 > # -----------------------
11499 > # Set $? to STATUS, without forking.
11500 > as_fn_set_status ()
11501 > {
11502 >  return $1
11503 > } # as_fn_set_status
11504 >
11505 > # as_fn_exit STATUS
11506 > # -----------------
11507 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
11508 > as_fn_exit ()
11509 > {
11510 >  set +e
11511 >  as_fn_set_status $1
11512 >  exit $1
11513 > } # as_fn_exit
11514 >
11515 > # as_fn_unset VAR
11516 > # ---------------
11517 > # Portably unset VAR.
11518 > as_fn_unset ()
11519 > {
11520 >  { eval $1=; unset $1;}
11521 > }
11522 > as_unset=as_fn_unset
11523 > # as_fn_append VAR VALUE
11524 > # ----------------------
11525 > # Append the text in VALUE to the end of the definition contained in VAR. Take
11526 > # advantage of any shell optimizations that allow amortized linear growth over
11527 > # repeated appends, instead of the typical quadratic growth present in naive
11528 > # implementations.
11529 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
11530 >  eval 'as_fn_append ()
11531 >  {
11532 >    eval $1+=\$2
11533 >  }'
11534 > else
11535 >  as_fn_append ()
11536 >  {
11537 >    eval $1=\$$1\$2
11538 >  }
11539 > fi # as_fn_append
11540 >
11541 > # as_fn_arith ARG...
11542 > # ------------------
11543 > # Perform arithmetic evaluation on the ARGs, and store the result in the
11544 > # global $as_val. Take advantage of shells that can avoid forks. The arguments
11545 > # must be portable across $(()) and expr.
11546 > if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
11547 >  eval 'as_fn_arith ()
11548 >  {
11549 >    as_val=$(( $* ))
11550 >  }'
11551 > else
11552 >  as_fn_arith ()
11553 >  {
11554 >    as_val=`expr "$@" || test $? -eq 1`
11555 >  }
11556 > fi # as_fn_arith
11557 >
11558 >
11559   if expr a : '\(a\)' >/dev/null 2>&1 &&
11560     test "X`expr 00001 : '.*\(...\)'`" = X001; then
11561    as_expr=expr
# Line 13603 | Line 11569 | fi
11569    as_basename=false
11570   fi
11571  
11572 + if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
11573 +  as_dirname=dirname
11574 + else
11575 +  as_dirname=false
11576 + fi
11577  
13607 – # Name of the executable.
11578   as_me=`$as_basename -- "$0" ||
11579   $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11580           X"$0" : 'X\(//\)$' \| \
# Line 13624 | Line 11594 | $as_echo X/"$0" |
11594            }
11595            s/.*/./; q'`
11596  
11597 < # CDPATH.
11598 < $as_unset CDPATH
11597 > # Avoid depending upon Character Ranges.
11598 > as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11599 > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11600 > as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11601 > as_cr_digits='0123456789'
11602 > as_cr_alnum=$as_cr_Letters$as_cr_digits
11603  
13630 –
13631 –
13632 –  as_lineno_1=$LINENO
13633 –  as_lineno_2=$LINENO
13634 –  test "x$as_lineno_1" != "x$as_lineno_2" &&
13635 –  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
13636 –
13637 –  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13638 –  # uniformly replaced by the line number.  The first 'sed' inserts a
13639 –  # line-number line after each line using $LINENO; the second 'sed'
13640 –  # does the real work.  The second script uses 'N' to pair each
13641 –  # line-number line with the line containing $LINENO, and appends
13642 –  # trailing '-' during substitution so that $LINENO is not a special
13643 –  # case at line end.
13644 –  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13645 –  # scripts with optimization help from Paolo Bonzini.  Blame Lee
13646 –  # E. McMahon (1931-1989) for sed's syntax.  :-)
13647 –  sed -n '
13648 –    p
13649 –    /[$]LINENO/=
13650 –  ' <$as_myself |
13651 –    sed '
13652 –      s/[$]LINENO.*/&-/
13653 –      t lineno
13654 –      b
13655 –      :lineno
13656 –      N
13657 –      :loop
13658 –      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
13659 –      t loop
13660 –      s/-\n.*//
13661 –    ' >$as_me.lineno &&
13662 –  chmod +x "$as_me.lineno" ||
13663 –    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
13664 –   { (exit 1); exit 1; }; }
13665 –
13666 –  # Don't try to exec as it changes $[0], causing all sort of problems
13667 –  # (the dirname of $[0] is not the place where we might find the
13668 –  # original and so on.  Autoconf is especially sensitive to this).
13669 –  . "./$as_me.lineno"
13670 –  # Exit status is that of the last command.
13671 –  exit
13672 – }
13673 –
13674 –
13675 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
13676 –  as_dirname=dirname
13677 – else
13678 –  as_dirname=false
13679 – fi
13680 –
11604   ECHO_C= ECHO_N= ECHO_T=
11605 < case `echo -n x` in
11605 > case `echo -n x` in #(((((
11606   -n*)
11607 <  case `echo 'x\c'` in
11607 >  case `echo 'xy\c'` in
11608    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
11609 <  *)   ECHO_C='\c';;
11609 >  xy)  ECHO_C='\c';;
11610 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
11611 >       ECHO_T=' ';;
11612    esac;;
11613   *)
11614    ECHO_N='-n';;
11615   esac
13691 – if expr a : '\(a\)' >/dev/null 2>&1 &&
13692 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
13693 –  as_expr=expr
13694 – else
13695 –  as_expr=false
13696 – fi
11616  
11617   rm -f conf$$ conf$$.exe conf$$.file
11618   if test -d conf$$.dir; then
# Line 13721 | Line 11640 | rmdir conf$$.dir 2>/dev/null
11640   fi
11641   rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
11642   rmdir conf$$.dir 2>/dev/null
11643 +
11644 +
11645 + # as_fn_mkdir_p
11646 + # -------------
11647 + # Create "$as_dir" as a directory, including parents if necessary.
11648 + as_fn_mkdir_p ()
11649 + {
11650 +
11651 +  case $as_dir in #(
11652 +  -*) as_dir=./$as_dir;;
11653 +  esac
11654 +  test -d "$as_dir" || eval $as_mkdir_p || {
11655 +    as_dirs=
11656 +    while :; do
11657 +      case $as_dir in #(
11658 +      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
11659 +      *) as_qdir=$as_dir;;
11660 +      esac
11661 +      as_dirs="'$as_qdir' $as_dirs"
11662 +      as_dir=`$as_dirname -- "$as_dir" ||
11663 + $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
11664 +         X"$as_dir" : 'X\(//\)[^/]' \| \
11665 +         X"$as_dir" : 'X\(//\)$' \| \
11666 +         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
11667 + $as_echo X"$as_dir" |
11668 +    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
11669 +            s//\1/
11670 +            q
11671 +          }
11672 +          /^X\(\/\/\)[^/].*/{
11673 +            s//\1/
11674 +            q
11675 +          }
11676 +          /^X\(\/\/\)$/{
11677 +            s//\1/
11678 +            q
11679 +          }
11680 +          /^X\(\/\).*/{
11681 +            s//\1/
11682 +            q
11683 +          }
11684 +          s/.*/./; q'`
11685 +      test -d "$as_dir" && break
11686 +    done
11687 +    test -z "$as_dirs" || eval "mkdir $as_dirs"
11688 +  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
11689  
11690 +
11691 + } # as_fn_mkdir_p
11692   if mkdir -p . 2>/dev/null; then
11693 <  as_mkdir_p=:
11693 >  as_mkdir_p='mkdir -p "$as_dir"'
11694   else
11695    test -d ./-p && rmdir ./-p
11696    as_mkdir_p=false
# Line 13742 | Line 11709 | else
11709        if test -d "$1"; then
11710          test -d "$1/.";
11711        else
11712 <        case $1 in
11712 >        case $1 in #(
11713          -*)set "./$1";;
11714          esac;
11715 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
11715 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
11716          ???[sx]*):;;*)false;;esac;fi
11717      '\'' sh
11718    '
# Line 13760 | Line 11727 | exec 6>&1
11727  
11728  
11729   exec 6>&1
11730 + ## ----------------------------------- ##
11731 + ## Main body of $CONFIG_STATUS script. ##
11732 + ## ----------------------------------- ##
11733 + _ASEOF
11734 + test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
11735  
11736 < # Save the log message, to keep $[0] and so on meaningful, and to
11736 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
11737 > # Save the log message, to keep $0 and so on meaningful, and to
11738   # report actual input values of CONFIG_FILES etc. instead of their
11739   # values after options handling.
11740   ac_log="
11741   This file was extended by OOPSE $as_me 4.0, which was
11742 < generated by GNU Autoconf 2.62.  Invocation command line was
11742 > generated by GNU Autoconf 2.64.  Invocation command line was
11743  
11744    CONFIG_FILES    = $CONFIG_FILES
11745    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 13779 | Line 11752 | _ACEOF
11752  
11753   _ACEOF
11754  
11755 + case $ac_config_files in *"
11756 + "*) set x $ac_config_files; shift; ac_config_files=$*;;
11757 + esac
11758 +
11759 + case $ac_config_headers in *"
11760 + "*) set x $ac_config_headers; shift; ac_config_headers=$*;;
11761 + esac
11762 +
11763 +
11764   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
11765   # Files that config.status was made for.
11766   config_files="$ac_config_files"
# Line 13788 | Line 11770 | ac_cs_usage="\
11770  
11771   cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
11772   ac_cs_usage="\
11773 < \`$as_me' instantiates files from templates according to the
11774 < current configuration.
11773 > \`$as_me' instantiates files and other configuration actions
11774 > from templates according to the current configuration.  Unless the files
11775 > and actions are specified as TAGs, all are instantiated by default.
11776  
11777 < Usage: $0 [OPTIONS] [FILE]...
11777 > Usage: $0 [OPTION]... [TAG]...
11778  
11779    -h, --help       print this help, then exit
11780    -V, --version    print version number and configuration settings, then exit
11781 <  -q, --quiet      do not print progress messages
11781 >  -q, --quiet, --silent
11782 >                   do not print progress messages
11783    -d, --debug      don't remove temporary files
11784        --recheck    update $as_me by reconfiguring in the same conditions
11785 <  --file=FILE[:TEMPLATE]
11785 >      --file=FILE[:TEMPLATE]
11786                     instantiate the configuration file FILE
11787 <  --header=FILE[:TEMPLATE]
11787 >      --header=FILE[:TEMPLATE]
11788                     instantiate the configuration header FILE
11789  
11790   Configuration files:
# Line 13809 | Line 11793 | $config_headers
11793   Configuration headers:
11794   $config_headers
11795  
11796 < Report bugs to <bug-autoconf@gnu.org>."
11796 > Report bugs to <gezelter@nd.edu>."
11797  
11798   _ACEOF
11799   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
11800   ac_cs_version="\\
11801   OOPSE config.status 4.0
11802 < configured by $0, generated by GNU Autoconf 2.62,
11802 > configured by $0, generated by GNU Autoconf 2.64,
11803    with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
11804  
11805 < Copyright (C) 2008 Free Software Foundation, Inc.
11805 > Copyright (C) 2009 Free Software Foundation, Inc.
11806   This config.status script is free software; the Free Software Foundation
11807   gives unlimited permission to copy, distribute and modify it."
11808  
# Line 13859 | Line 11843 | do
11843      case $ac_optarg in
11844      *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
11845      esac
11846 <    CONFIG_FILES="$CONFIG_FILES '$ac_optarg'"
11846 >    as_fn_append CONFIG_FILES " '$ac_optarg'"
11847      ac_need_defaults=false;;
11848    --header | --heade | --head | --hea )
11849      $ac_shift
11850      case $ac_optarg in
11851      *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
11852      esac
11853 <    CONFIG_HEADERS="$CONFIG_HEADERS '$ac_optarg'"
11853 >    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
11854      ac_need_defaults=false;;
11855    --he | --h)
11856      # Conflict between --help and --header
11857 <    { $as_echo "$as_me: error: ambiguous option: $1
11858 < Try \`$0 --help' for more information." >&2
13875 <   { (exit 1); exit 1; }; };;
11857 >    as_fn_error "ambiguous option: \`$1'
11858 > Try \`$0 --help' for more information.";;
11859    --help | --hel | -h )
11860      $as_echo "$ac_cs_usage"; exit ;;
11861    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
# Line 13880 | Line 11863 | Try \`$0 --help' for more information." >&2
11863      ac_cs_silent=: ;;
11864  
11865    # This is an error.
11866 <  -*) { $as_echo "$as_me: error: unrecognized option: $1
11867 < Try \`$0 --help' for more information." >&2
13885 <   { (exit 1); exit 1; }; } ;;
11866 >  -*) as_fn_error "unrecognized option: \`$1'
11867 > Try \`$0 --help' for more information." ;;
11868  
11869 <  *) ac_config_targets="$ac_config_targets $1"
11869 >  *) as_fn_append ac_config_targets " $1"
11870       ac_need_defaults=false ;;
11871  
11872    esac
# Line 13934 | Line 11916 | do
11916      "make/Makefile") CONFIG_FILES="$CONFIG_FILES make/Makefile" ;;
11917      "src/utils/Makefile") CONFIG_FILES="$CONFIG_FILES src/utils/Makefile" ;;
11918      "src/math/Makefile") CONFIG_FILES="$CONFIG_FILES src/math/Makefile" ;;
11919 +    "src/integrators/Makefile") CONFIG_FILES="$CONFIG_FILES src/integrators/Makefile" ;;
11920      "src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
11921      "scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
11922  
11923 <  *) { { $as_echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13941 < $as_echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13942 <   { (exit 1); exit 1; }; };;
11923 >  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
11924    esac
11925   done
11926  
# Line 13965 | Line 11946 | $debug ||
11946    trap 'exit_status=$?
11947    { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
11948   ' 0
11949 <  trap '{ (exit 1); exit 1; }' 1 2 13 15
11949 >  trap 'as_fn_exit 1' 1 2 13 15
11950   }
11951   # Create a (secure) tmp directory for tmp files.
11952  
# Line 13976 | Line 11957 | $debug ||
11957   {
11958    tmp=./conf$$-$RANDOM
11959    (umask 077 && mkdir "$tmp")
11960 < } ||
13980 < {
13981 <   $as_echo "$as_me: cannot create a temporary directory in ." >&2
13982 <   { (exit 1); exit 1; }
13983 < }
11960 > } || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5
11961  
11962   # Set up the scripts for CONFIG_FILES section.
11963   # No need to generate them if there are no CONFIG_FILES.
# Line 13988 | Line 11965 | if test -n "$CONFIG_FILES"; then
11965   if test -n "$CONFIG_FILES"; then
11966  
11967  
11968 < ac_cr='
11969 < '
11968 > ac_cr=`echo X | tr X '\015'`
11969 > # On cygwin, bash can eat \r inside `` if the user requested igncr.
11970 > # But we know of no other shell where ac_cr would be empty at this
11971 > # point, so we can use a bashism as a fallback.
11972 > if test "x$ac_cr" = x; then
11973 >  eval ac_cr=\$\'\\r\'
11974 > fi
11975   ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
11976   if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
11977 <  ac_cs_awk_cr='\\r'
11977 >  ac_cs_awk_cr='\r'
11978   else
11979    ac_cs_awk_cr=$ac_cr
11980   fi
# Line 14006 | Line 11988 | _ACEOF
11988    echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
11989    echo "_ACEOF"
11990   } >conf$$subs.sh ||
11991 <  { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14010 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14011 <   { (exit 1); exit 1; }; }
11991 >  as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
11992   ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'`
11993   ac_delim='%!_!# '
11994   for ac_last_try in false false false false false :; do
11995    . ./conf$$subs.sh ||
11996 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14017 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14018 <   { (exit 1); exit 1; }; }
11996 >    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
11997  
11998 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` = $ac_delim_num; then
11998 >  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
11999 >  if test $ac_delim_n = $ac_delim_num; then
12000      break
12001    elif $ac_last_try; then
12002 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14024 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14025 <   { (exit 1); exit 1; }; }
12002 >    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
12003    else
12004      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
12005    fi
# Line 14111 | Line 12088 | fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
12088   else
12089    cat
12090   fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
12091 <  || { { $as_echo "$as_me:$LINENO: error: could not setup config files machinery" >&5
14115 < $as_echo "$as_me: error: could not setup config files machinery" >&2;}
14116 <   { (exit 1); exit 1; }; }
12091 >  || as_fn_error "could not setup config files machinery" "$LINENO" 5
12092   _ACEOF
12093  
12094   # VPATH may cause trouble with some makes, so we remove $(srcdir),
# Line 14154 | Line 12129 | for ac_last_try in false false :; do
12129    if test -z "$ac_t"; then
12130      break
12131    elif $ac_last_try; then
12132 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_HEADERS" >&5
14158 < $as_echo "$as_me: error: could not make $CONFIG_HEADERS" >&2;}
14159 <   { (exit 1); exit 1; }; }
12132 >    as_fn_error "could not make $CONFIG_HEADERS" "$LINENO" 5
12133    else
12134      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
12135    fi
# Line 14222 | Line 12195 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
12195    }
12196    split(mac1, mac2, "(") #)
12197    macro = mac2[1]
12198 +  prefix = substr(line, 1, index(line, defundef) - 1)
12199    if (D_is_set[macro]) {
12200      # Preserve the white space surrounding the "#".
14227 –    prefix = substr(line, 1, index(line, defundef) - 1)
12201      print prefix "define", macro P[macro] D[macro]
12202      next
12203    } else {
# Line 14232 | Line 12205 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
12205      # in the case of _POSIX_SOURCE, which is predefined and required
12206      # on some systems where configure will not decide to define it.
12207      if (defundef == "undef") {
12208 <      print "/*", line, "*/"
12208 >      print "/*", prefix defundef, macro, "*/"
12209        next
12210      }
12211    }
# Line 14241 | Line 12214 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
12214   _ACAWK
12215   _ACEOF
12216   cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
12217 <  { { $as_echo "$as_me:$LINENO: error: could not setup config headers machinery" >&5
14245 < $as_echo "$as_me: error: could not setup config headers machinery" >&2;}
14246 <   { (exit 1); exit 1; }; }
12217 >  as_fn_error "could not setup config headers machinery" "$LINENO" 5
12218   fi # test -n "$CONFIG_HEADERS"
12219  
12220  
# Line 14256 | Line 12227 | do
12227    esac
12228    case $ac_mode$ac_tag in
12229    :[FHL]*:*);;
12230 <  :L* | :C*:*) { { $as_echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
14260 < $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
14261 <   { (exit 1); exit 1; }; };;
12230 >  :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;;
12231    :[FH]-) ac_tag=-:-;;
12232    :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
12233    esac
# Line 14286 | Line 12255 | $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
12255             [\\/$]*) false;;
12256             *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
12257             esac ||
12258 <           { { $as_echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
14290 < $as_echo "$as_me: error: cannot find input file: $ac_f" >&2;}
14291 <   { (exit 1); exit 1; }; };;
12258 >           as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;;
12259        esac
12260        case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
12261 <      ac_file_inputs="$ac_file_inputs '$ac_f'"
12261 >      as_fn_append ac_file_inputs " '$ac_f'"
12262      done
12263  
12264      # Let's still pretend it is `configure' which instantiates (i.e., don't
# Line 14302 | Line 12269 | $as_echo "$as_me: error: cannot find input file: $ac_f
12269          `' by configure.'
12270      if test x"$ac_file" != x-; then
12271        configure_input="$ac_file.  $configure_input"
12272 <      { $as_echo "$as_me:$LINENO: creating $ac_file" >&5
12272 >      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
12273   $as_echo "$as_me: creating $ac_file" >&6;}
12274      fi
12275      # Neutralize special characters interpreted by sed in replacement strings.
# Line 14315 | Line 12282 | $as_echo "$as_me: creating $ac_file" >&6;}
12282  
12283      case $ac_tag in
12284      *:-:* | *:-) cat >"$tmp/stdin" \
12285 <      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14319 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14320 <   { (exit 1); exit 1; }; } ;;
12285 >      || as_fn_error "could not create $ac_file" "$LINENO" 5 ;;
12286      esac
12287      ;;
12288    esac
# Line 14328 | Line 12293 | $as_echo X"$ac_file" |
12293           X"$ac_file" : 'X\(//\)$' \| \
12294           X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
12295   $as_echo X"$ac_file" |
14331 –    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14332 –            s//\1/
14333 –            q
14334 –          }
14335 –          /^X\(\/\/\)[^/].*/{
14336 –            s//\1/
14337 –            q
14338 –          }
14339 –          /^X\(\/\/\)$/{
14340 –            s//\1/
14341 –            q
14342 –          }
14343 –          /^X\(\/\).*/{
14344 –            s//\1/
14345 –            q
14346 –          }
14347 –          s/.*/./; q'`
14348 –  { as_dir="$ac_dir"
14349 –  case $as_dir in #(
14350 –  -*) as_dir=./$as_dir;;
14351 –  esac
14352 –  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
14353 –    as_dirs=
14354 –    while :; do
14355 –      case $as_dir in #(
14356 –      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
14357 –      *) as_qdir=$as_dir;;
14358 –      esac
14359 –      as_dirs="'$as_qdir' $as_dirs"
14360 –      as_dir=`$as_dirname -- "$as_dir" ||
14361 – $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14362 –         X"$as_dir" : 'X\(//\)[^/]' \| \
14363 –         X"$as_dir" : 'X\(//\)$' \| \
14364 –         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
14365 – $as_echo X"$as_dir" |
12296      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
12297              s//\1/
12298              q
# Line 14380 | Line 12310 | $as_echo X"$as_dir" |
12310              q
12311            }
12312            s/.*/./; q'`
12313 <      test -d "$as_dir" && break
14384 <    done
14385 <    test -z "$as_dirs" || eval "mkdir $as_dirs"
14386 <  } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
14387 < $as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
14388 <   { (exit 1); exit 1; }; }; }
12313 >  as_dir="$ac_dir"; as_fn_mkdir_p
12314    ac_builddir=.
12315  
12316   case "$ac_dir" in
# Line 14437 | Line 12362 | ac_datarootdir_hack=; ac_datarootdir_seen=
12362   # If the template does not know about datarootdir, expand it.
12363   # FIXME: This hack should be removed a few years after 2.60.
12364   ac_datarootdir_hack=; ac_datarootdir_seen=
14440 –
12365   ac_sed_dataroot='
12366   /datarootdir/ {
12367    p
# Line 14447 | Line 12371 | ac_sed_dataroot='
12371   /@docdir@/p
12372   /@infodir@/p
12373   /@localedir@/p
12374 < /@mandir@/p
14451 < '
12374 > /@mandir@/p'
12375   case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
12376   *datarootdir*) ac_datarootdir_seen=yes;;
12377   *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
12378 <  { $as_echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
12378 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
12379   $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
12380   _ACEOF
12381   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Line 14462 | Line 12385 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
12385    s&@infodir@&$infodir&g
12386    s&@localedir@&$localedir&g
12387    s&@mandir@&$mandir&g
12388 <    s&\\\${datarootdir}&$datarootdir&g' ;;
12388 >  s&\\\${datarootdir}&$datarootdir&g' ;;
12389   esac
12390   _ACEOF
12391  
# Line 14490 | Line 12413 | eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -
12413   $ac_datarootdir_hack
12414   "
12415   eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
12416 <  || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14494 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14495 <   { (exit 1); exit 1; }; }
12416 >  || as_fn_error "could not create $ac_file" "$LINENO" 5
12417  
12418   test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
12419    { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
12420    { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
12421 <  { $as_echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
12421 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
12422   which seems to be undefined.  Please make sure it is defined." >&5
12423   $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
12424   which seems to be undefined.  Please make sure it is defined." >&2;}
# Line 14507 | Line 12428 | which seems to be undefined.  Please make sure it is d
12428    -) cat "$tmp/out" && rm -f "$tmp/out";;
12429    *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
12430    esac \
12431 <  || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14511 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14512 <   { (exit 1); exit 1; }; }
12431 >  || as_fn_error "could not create $ac_file" "$LINENO" 5
12432   ;;
12433    :H)
12434    #
# Line 14520 | Line 12439 | $as_echo "$as_me: error: could not create $ac_file" >&
12439        $as_echo "/* $configure_input  */" \
12440        && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
12441      } >"$tmp/config.h" \
12442 <      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14524 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14525 <   { (exit 1); exit 1; }; }
12442 >      || as_fn_error "could not create $ac_file" "$LINENO" 5
12443      if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
12444 <      { $as_echo "$as_me:$LINENO: $ac_file is unchanged" >&5
12444 >      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
12445   $as_echo "$as_me: $ac_file is unchanged" >&6;}
12446      else
12447        rm -f "$ac_file"
12448        mv "$tmp/config.h" "$ac_file" \
12449 <        || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14533 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14534 <   { (exit 1); exit 1; }; }
12449 >        || as_fn_error "could not create $ac_file" "$LINENO" 5
12450      fi
12451    else
12452      $as_echo "/* $configure_input  */" \
12453        && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
12454 <      || { { $as_echo "$as_me:$LINENO: error: could not create -" >&5
14540 < $as_echo "$as_me: error: could not create -" >&2;}
14541 <   { (exit 1); exit 1; }; }
12454 >      || as_fn_error "could not create -" "$LINENO" 5
12455    fi
12456   ;;
12457  
# Line 14550 | Line 12463 | $as_echo "$as_me: error: could not create -" >&2;}
12463      "make/Makefile":F) chmod 0755 scripts/* ;;
12464      "src/utils/Makefile":F) chmod 0755 scripts/* ;;
12465      "src/math/Makefile":F) chmod 0755 scripts/* ;;
12466 +    "src/integrators/Makefile":F) chmod 0755 scripts/* ;;
12467      "src/applications/atom2md/Makefile":F) chmod 0755 scripts/* ;;
12468      "scripts/filepp":F) chmod 0755 scripts/* ;;
12469  
# Line 14557 | Line 12471 | done # for ac_tag
12471   done # for ac_tag
12472  
12473  
12474 < { (exit 0); exit 0; }
12474 > as_fn_exit 0
12475   _ACEOF
14562 – chmod +x $CONFIG_STATUS
12476   ac_clean_files=$ac_clean_files_save
12477  
12478   test $ac_write_fail = 0 ||
12479 <  { { $as_echo "$as_me:$LINENO: error: write failure creating $CONFIG_STATUS" >&5
14567 < $as_echo "$as_me: error: write failure creating $CONFIG_STATUS" >&2;}
14568 <   { (exit 1); exit 1; }; }
12479 >  as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5
12480  
12481  
12482   # configure is writing to config.log, and then calls config.status.
# Line 14586 | Line 12497 | if test "$no_create" != yes; then
12497    exec 5>>config.log
12498    # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12499    # would make configure fail if this is the last instruction.
12500 <  $ac_cs_success || { (exit 1); exit 1; }
12500 >  $ac_cs_success || as_fn_exit $?
12501   fi
12502   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
12503 <  { $as_echo "$as_me:$LINENO: WARNING: Unrecognized options: $ac_unrecognized_opts" >&5
12504 < $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2;}
12503 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
12504 > $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
12505   fi
12506  

Diff Legend

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