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 1311 by gezelter, Tue Oct 21 18:50:37 2008 UTC vs.
branches/development/configure (file contents), Revision 1618 by gezelter, Mon Sep 12 17:09:26 2011 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.68 for OpenMD 1.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
7 + #
8   # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
9 < # 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
9 > # 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
10 > # Foundation, Inc.
11 > #
12 > #
13   # This configure script is free software; the Free Software Foundation
14   # gives unlimited permission to copy, distribute and modify it.
15 < ## --------------------- ##
16 < ## M4sh Initialization.  ##
17 < ## --------------------- ##
15 > ## -------------------- ##
16 > ## M4sh Initialization. ##
17 > ## -------------------- ##
18  
19   # Be more Bourne compatible
20   DUALCASE=1; export DUALCASE # for MKS sh
21 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
21 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
22    emulate sh
23    NULLCMD=:
24    # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# Line 22 | Line 26 | else
26    alias -g '${1+"$@"}'='"$@"'
27    setopt NO_GLOB_SUBST
28   else
29 <  case `(set -o) 2>/dev/null` in
30 <  *posix*) set -o posix ;;
29 >  case `(set -o) 2>/dev/null` in #(
30 >  *posix*) :
31 >    set -o posix ;; #(
32 >  *) :
33 >     ;;
34   esac
28 –
35   fi
36  
37  
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 –
38   as_nl='
39   '
40   export as_nl
# Line 46 | Line 42 | as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
42   as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
43   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
44   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
45 < if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
45 > # Prefer a ksh shell builtin over an external printf program on Solaris,
46 > # but without wasting forks for bash or zsh.
47 > if test -z "$BASH_VERSION$ZSH_VERSION" \
48 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
49 >  as_echo='print -r --'
50 >  as_echo_n='print -rn --'
51 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
52    as_echo='printf %s\n'
53    as_echo_n='printf %s'
54   else
# Line 57 | Line 59 | else
59      as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
60      as_echo_n_body='eval
61        arg=$1;
62 <      case $arg in
62 >      case $arg in #(
63        *"$as_nl"*)
64          expr "X$arg" : "X\\(.*\\)$as_nl";
65          arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
# Line 80 | Line 82 | fi
82    }
83   fi
84  
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
85  
90 –
86   # IFS
87   # We need space, tab and new line, in precisely that order.  Quoting is
88   # there to prevent editors from complaining about space-tab.
# Line 96 | Line 91 | IFS=" ""       $as_nl"
91   IFS=" ""        $as_nl"
92  
93   # Find who we are.  Look in the path if we contain no directory separator.
94 < case $0 in
94 > as_myself=
95 > case $0 in #((
96    *[\\/]* ) as_myself=$0 ;;
97    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
98   for as_dir in $PATH
99   do
100    IFS=$as_save_IFS
101    test -z "$as_dir" && as_dir=.
102 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
103 < done
102 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
103 >  done
104   IFS=$as_save_IFS
105  
106       ;;
# Line 116 | Line 112 | if test ! -f "$as_myself"; then
112   fi
113   if test ! -f "$as_myself"; then
114    $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
115 <  { (exit 1); exit 1; }
115 >  exit 1
116   fi
117  
118 < # Work around bugs in pre-3.0 UWIN ksh.
119 < for as_var in ENV MAIL MAILPATH
120 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
118 > # Unset variables that we do not need and which cause bugs (e.g. in
119 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
120 > # suppresses any "Segmentation fault" message there.  '((' could
121 > # trigger a bug in pdksh 5.2.14.
122 > for as_var in BASH_ENV ENV MAIL MAILPATH
123 > do eval test x\${$as_var+set} = xset \
124 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
125   done
126   PS1='$ '
127   PS2='> '
# Line 133 | Line 133 | export LANGUAGE
133   LANGUAGE=C
134   export LANGUAGE
135  
136 < # Required to use basename.
137 < 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
136 > # CDPATH.
137 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
138  
139 < if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
140 <  as_basename=basename
139 > if test "x$CONFIG_SHELL" = x; then
140 >  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
141 >  emulate sh
142 >  NULLCMD=:
143 >  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
144 >  # is contrary to our usage.  Disable this feature.
145 >  alias -g '\${1+\"\$@\"}'='\"\$@\"'
146 >  setopt NO_GLOB_SUBST
147   else
148 <  as_basename=false
148 >  case \`(set -o) 2>/dev/null\` in #(
149 >  *posix*) :
150 >    set -o posix ;; #(
151 >  *) :
152 >     ;;
153 > esac
154   fi
155 + "
156 +  as_required="as_fn_return () { (exit \$1); }
157 + as_fn_success () { as_fn_return 0; }
158 + as_fn_failure () { as_fn_return 1; }
159 + as_fn_ret_success () { return 0; }
160 + as_fn_ret_failure () { return 1; }
161  
162 + exitcode=0
163 + as_fn_success || { exitcode=1; echo as_fn_success failed.; }
164 + as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
165 + as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
166 + as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
167 + if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
168  
169 < # Name of the executable.
170 < as_me=`$as_basename -- "$0" ||
171 < $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
172 <         X"$0" : 'X\(//\)$' \| \
173 <         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
174 < $as_echo X/"$0" |
175 <    sed '/^.*\/\([^/][^/]*\)\/*$/{
176 <            s//\1/
177 <            q
178 <          }
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
169 > else
170 >  exitcode=1; echo positional parameters were not saved.
171 > fi
172 > test x\$exitcode = x0 || exit 1"
173 >  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
174 >  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
175 >  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
176 >  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
177 > test \$(( 1 + 1 )) = 2 || exit 1"
178 >  if (eval "$as_required") 2>/dev/null; then :
179    as_have_required=yes
180   else
181    as_have_required=no
182   fi
183 +  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
184  
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 –  :
185   else
186 <  exitcode=1
187 <  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
186 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
187 > as_found=false
188   for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
189   do
190    IFS=$as_save_IFS
191    test -z "$as_dir" && as_dir=.
192 <  case $as_dir in
192 >  as_found=:
193 >  case $as_dir in #(
194           /*)
195             for as_base in sh bash ksh sh5; do
196 <             as_candidate_shells="$as_candidate_shells $as_dir/$as_base"
196 >             # Try only shells that exist, to save several forks.
197 >             as_shell=$as_dir/$as_base
198 >             if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
199 >                    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
200 >  CONFIG_SHELL=$as_shell as_have_required=yes
201 >                   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
202 >  break 2
203 > fi
204 > fi
205             done;;
206         esac
207 +  as_found=false
208   done
209 + $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
210 +              { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
211 +  CONFIG_SHELL=$SHELL as_have_required=yes
212 + fi; }
213   IFS=$as_save_IFS
214  
215  
216 <      for as_shell in $as_candidate_shells $SHELL; do
217 <         # Try only shells that exist, to save several forks.
218 <         if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
219 <                { ("$as_shell") 2> /dev/null <<\_ASEOF
220 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
221 <  emulate sh
222 <  NULLCMD=:
223 <  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
224 <  # is contrary to our usage.  Disable this feature.
225 <  alias -g '${1+"$@"}'='"$@"'
226 <  setopt NO_GLOB_SUBST
227 < else
228 <  case `(set -o) 2>/dev/null` in
229 <  *posix*) set -o posix ;;
230 < esac
231 <
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 < }
313 <
314 < exitcode=0
315 < if as_func_success; then
316 <  :
317 < else
318 <  exitcode=1
319 <  echo as_func_success failed.
216 >      if test "x$CONFIG_SHELL" != x; then :
217 >  # We cannot yet assume a decent shell, so we have to provide a
218 >        # neutralization value for shells without unset; and this also
219 >        # works around shells that cannot unset nonexistent variables.
220 >        # Preserve -v and -x to the replacement shell.
221 >        BASH_ENV=/dev/null
222 >        ENV=/dev/null
223 >        (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
224 >        export CONFIG_SHELL
225 >        case $- in # ((((
226 >          *v*x* | *x*v* ) as_opts=-vx ;;
227 >          *v* ) as_opts=-v ;;
228 >          *x* ) as_opts=-x ;;
229 >          * ) as_opts= ;;
230 >        esac
231 >        exec "$CONFIG_SHELL" $as_opts "$as_myself" ${1+"$@"}
232   fi
233  
234 < if as_func_failure; then
235 <  exitcode=1
236 <  echo as_func_failure succeeded.
234 >    if test x$as_have_required = xno; then :
235 >  $as_echo "$0: This script requires a shell more modern than all"
236 >  $as_echo "$0: the shells that I found on your system."
237 >  if test x${ZSH_VERSION+set} = xset ; then
238 >    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
239 >    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
240 >  else
241 >    $as_echo "$0: Please tell bug-autoconf@gnu.org and gezelter@nd.edu
242 > $0: about your system, including any error possibly output
243 > $0: before this message. Then install a modern shell, or
244 > $0: manually run the script under such a shell if you do
245 > $0: have one."
246 >  fi
247 >  exit 1
248   fi
326 –
327 – if as_func_ret_success; then
328 –  :
329 – else
330 –  exitcode=1
331 –  echo as_func_ret_success failed.
249   fi
333 –
334 – if as_func_ret_failure; then
335 –  exitcode=1
336 –  echo as_func_ret_failure succeeded.
250   fi
251 + SHELL=${CONFIG_SHELL-/bin/sh}
252 + export SHELL
253 + # Unset more variables known to interfere with behavior of common tools.
254 + CLICOLOR_FORCE= GREP_OPTIONS=
255 + unset CLICOLOR_FORCE GREP_OPTIONS
256  
257 < if ( set x; as_func_ret_success y && test x = "$1" ); then
258 <  :
259 < else
260 <  exitcode=1
261 <  echo positional parameters were not saved.
262 < fi
257 > ## --------------------- ##
258 > ## M4sh Shell Functions. ##
259 > ## --------------------- ##
260 > # as_fn_unset VAR
261 > # ---------------
262 > # Portably unset VAR.
263 > as_fn_unset ()
264 > {
265 >  { eval $1=; unset $1;}
266 > }
267 > as_unset=as_fn_unset
268  
269 < test $exitcode = 0) || { (exit 1); exit 1; }
269 > # as_fn_set_status STATUS
270 > # -----------------------
271 > # Set $? to STATUS, without forking.
272 > as_fn_set_status ()
273 > {
274 >  return $1
275 > } # as_fn_set_status
276  
277 < (
278 <  as_lineno_1=$LINENO
279 <  as_lineno_2=$LINENO
280 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
281 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
277 > # as_fn_exit STATUS
278 > # -----------------
279 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
280 > as_fn_exit ()
281 > {
282 >  set +e
283 >  as_fn_set_status $1
284 >  exit $1
285 > } # as_fn_exit
286  
287 < _ASEOF
288 < }; then
289 <  break
290 < fi
287 > # as_fn_mkdir_p
288 > # -------------
289 > # Create "$as_dir" as a directory, including parents if necessary.
290 > as_fn_mkdir_p ()
291 > {
292  
293 < fi
293 >  case $as_dir in #(
294 >  -*) as_dir=./$as_dir;;
295 >  esac
296 >  test -d "$as_dir" || eval $as_mkdir_p || {
297 >    as_dirs=
298 >    while :; do
299 >      case $as_dir in #(
300 >      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
301 >      *) as_qdir=$as_dir;;
302 >      esac
303 >      as_dirs="'$as_qdir' $as_dirs"
304 >      as_dir=`$as_dirname -- "$as_dir" ||
305 > $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
306 >         X"$as_dir" : 'X\(//\)[^/]' \| \
307 >         X"$as_dir" : 'X\(//\)$' \| \
308 >         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
309 > $as_echo X"$as_dir" |
310 >    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
311 >            s//\1/
312 >            q
313 >          }
314 >          /^X\(\/\/\)[^/].*/{
315 >            s//\1/
316 >            q
317 >          }
318 >          /^X\(\/\/\)$/{
319 >            s//\1/
320 >            q
321 >          }
322 >          /^X\(\/\).*/{
323 >            s//\1/
324 >            q
325 >          }
326 >          s/.*/./; q'`
327 >      test -d "$as_dir" && break
328 >    done
329 >    test -z "$as_dirs" || eval "mkdir $as_dirs"
330 >  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
331  
361 –      done
332  
333 <      if test "x$CONFIG_SHELL" != x; then
334 <  for as_var in BASH_ENV ENV
335 <        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
336 <        done
337 <        export CONFIG_SHELL
338 <        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
339 < fi
333 > } # as_fn_mkdir_p
334 > # as_fn_append VAR VALUE
335 > # ----------------------
336 > # Append the text in VALUE to the end of the definition contained in VAR. Take
337 > # advantage of any shell optimizations that allow amortized linear growth over
338 > # repeated appends, instead of the typical quadratic growth present in naive
339 > # implementations.
340 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
341 >  eval 'as_fn_append ()
342 >  {
343 >    eval $1+=\$2
344 >  }'
345 > else
346 >  as_fn_append ()
347 >  {
348 >    eval $1=\$$1\$2
349 >  }
350 > fi # as_fn_append
351  
352 + # as_fn_arith ARG...
353 + # ------------------
354 + # Perform arithmetic evaluation on the ARGs, and store the result in the
355 + # global $as_val. Take advantage of shells that can avoid forks. The arguments
356 + # must be portable across $(()) and expr.
357 + if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
358 +  eval 'as_fn_arith ()
359 +  {
360 +    as_val=$(( $* ))
361 +  }'
362 + else
363 +  as_fn_arith ()
364 +  {
365 +    as_val=`expr "$@" || test $? -eq 1`
366 +  }
367 + fi # as_fn_arith
368  
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
369  
370 + # as_fn_error STATUS ERROR [LINENO LOG_FD]
371 + # ----------------------------------------
372 + # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
373 + # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
374 + # script with STATUS, using 1 if that was 0.
375 + as_fn_error ()
376 + {
377 +  as_status=$1; test $as_status -eq 0 && as_status=1
378 +  if test "$4"; then
379 +    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
380 +    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
381 +  fi
382 +  $as_echo "$as_me: error: $2" >&2
383 +  as_fn_exit $as_status
384 + } # as_fn_error
385  
386 < fi
387 <
388 < 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 <  :
386 > if expr a : '\(a\)' >/dev/null 2>&1 &&
387 >   test "X`expr 00001 : '.*\(...\)'`" = X001; then
388 >  as_expr=expr
389   else
390 <  exitcode=1
408 <  echo as_func_success failed.
390 >  as_expr=false
391   fi
392  
393 < if as_func_failure; then
394 <  exitcode=1
413 <  echo as_func_failure succeeded.
414 < fi
415 <
416 < if as_func_ret_success; then
417 <  :
393 > if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
394 >  as_basename=basename
395   else
396 <  exitcode=1
420 <  echo as_func_ret_success failed.
421 < fi
422 <
423 < if as_func_ret_failure; then
424 <  exitcode=1
425 <  echo as_func_ret_failure succeeded.
396 >  as_basename=false
397   fi
398  
399 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
400 <  :
399 > if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
400 >  as_dirname=dirname
401   else
402 <  exitcode=1
432 <  echo positional parameters were not saved.
402 >  as_dirname=false
403   fi
404  
405 < test \$exitcode = 0") || {
406 <  echo No shell found that supports shell functions.
407 <  echo Please tell bug-autoconf@gnu.org about your system,
408 <  echo including any error possibly output before this message.
409 <  echo This can help us improve future autoconf versions.
410 <  echo Configuration will now proceed without shell functions.
411 < }
405 > as_me=`$as_basename -- "$0" ||
406 > $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
407 >         X"$0" : 'X\(//\)$' \| \
408 >         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
409 > $as_echo X/"$0" |
410 >    sed '/^.*\/\([^/][^/]*\)\/*$/{
411 >            s//\1/
412 >            q
413 >          }
414 >          /^X\/\(\/\/\)$/{
415 >            s//\1/
416 >            q
417 >          }
418 >          /^X\/\(\/\).*/{
419 >            s//\1/
420 >            q
421 >          }
422 >          s/.*/./; q'`
423  
424 + # Avoid depending upon Character Ranges.
425 + as_cr_letters='abcdefghijklmnopqrstuvwxyz'
426 + as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
427 + as_cr_Letters=$as_cr_letters$as_cr_LETTERS
428 + as_cr_digits='0123456789'
429 + as_cr_alnum=$as_cr_Letters$as_cr_digits
430  
431  
432 <  as_lineno_1=$LINENO
433 <  as_lineno_2=$LINENO
434 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
435 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
436 <
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.  :-)
432 >  as_lineno_1=$LINENO as_lineno_1a=$LINENO
433 >  as_lineno_2=$LINENO as_lineno_2a=$LINENO
434 >  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
435 >  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
436 >  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
437    sed -n '
438      p
439      /[$]LINENO/=
# Line 473 | Line 450 | test \$exitcode = 0") || {
450        s/-\n.*//
451      ' >$as_me.lineno &&
452    chmod +x "$as_me.lineno" ||
453 <    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
477 <   { (exit 1); exit 1; }; }
453 >    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
454  
455    # Don't try to exec as it changes $[0], causing all sort of problems
456    # (the dirname of $[0] is not the place where we might find the
# Line 484 | Line 460 | test \$exitcode = 0") || {
460    exit
461   }
462  
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 –
463   ECHO_C= ECHO_N= ECHO_T=
464 < case `echo -n x` in
464 > case `echo -n x` in #(((((
465   -n*)
466 <  case `echo 'x\c'` in
466 >  case `echo 'xy\c'` in
467    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
468 <  *)   ECHO_C='\c';;
468 >  xy)  ECHO_C='\c';;
469 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
470 >       ECHO_T=' ';;
471    esac;;
472   *)
473    ECHO_N='-n';;
474   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
475  
476   rm -f conf$$ conf$$.exe conf$$.file
477   if test -d conf$$.dir; then
# Line 536 | Line 501 | if mkdir -p . 2>/dev/null; then
501   rmdir conf$$.dir 2>/dev/null
502  
503   if mkdir -p . 2>/dev/null; then
504 <  as_mkdir_p=:
504 >  as_mkdir_p='mkdir -p "$as_dir"'
505   else
506    test -d ./-p && rmdir ./-p
507    as_mkdir_p=false
# Line 555 | Line 520 | else
520        if test -d "$1"; then
521          test -d "$1/.";
522        else
523 <        case $1 in
523 >        case $1 in #(
524          -*)set "./$1";;
525          esac;
526 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
526 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
527          ???[sx]*):;;*)false;;esac;fi
528      '\'' sh
529    '
# Line 572 | Line 537 | as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
537   as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
538  
539  
540 + test -n "$DJDIR" || exec 7<&0 </dev/null
541 + exec 6>&1
542  
576 – exec 7<&0 </dev/null 6>&1
577 –
543   # Name of the host.
544 < # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
544 > # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
545   # so uname gets run too.
546   ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
547  
# Line 591 | Line 556 | MAKEFLAGS=
556   subdirs=
557   MFLAGS=
558   MAKEFLAGS=
594 – SHELL=${CONFIG_SHELL-/bin/sh}
559  
560   # Identity of this package.
561 < PACKAGE_NAME='OOPSE'
562 < PACKAGE_TARNAME='oopse'
563 < PACKAGE_VERSION='4.0'
564 < PACKAGE_STRING='OOPSE 4.0'
561 > PACKAGE_NAME='OpenMD'
562 > PACKAGE_TARNAME='openmd'
563 > PACKAGE_VERSION='1.0'
564 > PACKAGE_STRING='OpenMD 1.0'
565   PACKAGE_BUGREPORT='gezelter@nd.edu'
566 + PACKAGE_URL=''
567  
568 < ac_unique_file="src/applications/oopse/oopse.cpp"
568 > ac_unique_file="src/applications/openmd/openmd.cpp"
569   ac_default_prefix="/usr/local"
570   # Factoring default headers for most tests.
571   ac_includes_default="\
# Line 638 | Line 603 | ac_includes_default="\
603   # include <unistd.h>
604   #endif"
605  
606 < ac_subst_vars='SHELL
607 < PATH_SEPARATOR
608 < PACKAGE_NAME
609 < PACKAGE_TARNAME
610 < PACKAGE_VERSION
611 < PACKAGE_STRING
612 < PACKAGE_BUGREPORT
613 < exec_prefix
614 < prefix
615 < program_transform_name
616 < bindir
617 < sbindir
618 < libexecdir
619 < datarootdir
620 < datadir
621 < sysconfdir
622 < sharedstatedir
623 < localstatedir
624 < includedir
625 < oldincludedir
626 < docdir
627 < infodir
628 < htmldir
629 < dvidir
630 < pdfdir
631 < psdir
632 < libdir
633 < localedir
634 < mandir
635 < DEFS
636 < ECHO_C
637 < ECHO_N
638 < ECHO_T
639 < LIBS
640 < build_alias
641 < host_alias
642 < target_alias
643 < build
644 < build_cpu
645 < build_vendor
646 < build_os
647 < host
683 < host_cpu
684 < host_vendor
685 < host_os
686 < PROGNAME
687 < debug
688 < USE_SINGLE_PRECISION
689 < ac_cc_set
690 < ac_cc_path
691 < ac_cxx_set
692 < ac_cxx_path
693 < ac_fc_set
694 < ac_fc_path
695 < acx_mpi_mpicc
696 < acx_mpi_mpicc_path
697 < acx_mpi_mpif90
698 < acx_mpi_mpif90_path
699 < acx_mpi_mpicxx
700 < acx_mpi_mpicxx_path
701 < MPI_CPPFLAGS
702 < MPI_LIBS
703 < MPI90_LIBS
606 > ac_subst_vars='LTLIBOBJS
607 > SUBDIRS
608 > OPENMD_HOME
609 > OPENMD
610 > MKINSTALLDIRS
611 > BATEXT
612 > enable_latex_docs
613 > enable_html_docs
614 > enable_dot
615 > DOC
616 > DOT
617 > DOXYGEN
618 > POW_LIB
619 > LIBOBJS
620 > USE_OPENBABEL
621 > OPENBABEL_LIB
622 > OPENBABEL_LIB_DIR
623 > OPENBABEL_INC_DIR
624 > CXXCPP
625 > USE_QHULL
626 > QHULL
627 > QHULL_LIB_DIR
628 > QHULL_INC_DIR
629 > FFTW_LIBS
630 > FFTW_LIB_DIR
631 > FFTW_INC_DIR
632 > ZLIB
633 > ZLIB_LIB_DIR
634 > ZLIB_INC_DIR
635 > PS
636 > AR
637 > INSTALL_DATA
638 > INSTALL_SCRIPT
639 > INSTALL_PROGRAM
640 > PERL_SHEBANG
641 > PERLINTERP
642 > RANLIB
643 > SET_MAKE
644 > LN_S
645 > EGREP
646 > GREP
647 > CPP
648   USE_MPI
649 < CXX
650 < CXXFLAGS
651 < LDFLAGS
652 < CPPFLAGS
709 < ac_ct_CXX
710 < EXEEXT
711 < OBJEXT
712 < CC
713 < CFLAGS
649 > MPICC
650 > MPILIBS
651 > MPICXX
652 > LIBDL
653   ac_ct_CC
654 < FC
655 < FCFLAGS
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
773 < OOPSE
774 < OOPSE_HOME
775 < SUBDIRS
776 < LTLIBOBJS'
654 > CFLAGS
655 > CC
656 > OBJEXT
657 > EXEEXT
658 > ac_ct_CXX
659 > CPPFLAGS
660 > LDFLAGS
661 > CXXFLAGS
662 > CXX
663 > USE_SINGLE_PRECISION
664 > debug
665 > PROGNAME
666 > host_os
667 > host_vendor
668 > host_cpu
669 > host
670 > build_os
671 > build_vendor
672 > build_cpu
673 > build
674 > target_alias
675 > host_alias
676 > build_alias
677 > LIBS
678 > ECHO_T
679 > ECHO_N
680 > ECHO_C
681 > DEFS
682 > mandir
683 > localedir
684 > libdir
685 > psdir
686 > pdfdir
687 > dvidir
688 > htmldir
689 > infodir
690 > docdir
691 > oldincludedir
692 > includedir
693 > localstatedir
694 > sharedstatedir
695 > sysconfdir
696 > datadir
697 > datarootdir
698 > libexecdir
699 > sbindir
700 > bindir
701 > program_transform_name
702 > prefix
703 > exec_prefix
704 > PACKAGE_URL
705 > PACKAGE_BUGREPORT
706 > PACKAGE_STRING
707 > PACKAGE_VERSION
708 > PACKAGE_TARNAME
709 > PACKAGE_NAME
710 > PATH_SEPARATOR
711 > SHELL'
712   ac_subst_files=''
713   ac_user_opts='
714   enable_option_checking
715 < enable_oopse_home
715 > enable_openmd_home
716   enable_debug
717   enable_single
718   enable_float
784 – with_mpi
719   with_perl_shebang
720   with_zlib
721   with_fftw
722   with_qhull
723   with_openbabel
790 – with_cgalmakefile
724   enable_doxygen
725   enable_dot
726   enable_html_docs
# Line 804 | Line 737 | CFLAGS
737   CCC
738   CC
739   CFLAGS
740 < FC
741 < FCFLAGS
740 > MPICXX
741 > MPICC
742   CPP
743   CXXCPP'
744  
# Line 870 | Line 803 | do
803    fi
804  
805    case $ac_option in
806 <  *=*)  ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
807 <  *)    ac_optarg=yes ;;
806 >  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
807 >  *=)   ac_optarg= ;;
808 >  *)    ac_optarg=yes ;;
809    esac
810  
811    # Accept the important Cygnus configure options, so we can diagnose typos.
# Line 916 | Line 850 | do
850      ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
851      # Reject names that are not valid shell variable names.
852      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
853 <      { $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
920 <   { (exit 1); exit 1; }; }
853 >      as_fn_error $? "invalid feature name: $ac_useropt"
854      ac_useropt_orig=$ac_useropt
855      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
856      case $ac_user_opts in
# Line 943 | Line 876 | do
876      ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
877      # Reject names that are not valid shell variable names.
878      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
879 <      { $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
947 <   { (exit 1); exit 1; }; }
879 >      as_fn_error $? "invalid feature name: $ac_useropt"
880      ac_useropt_orig=$ac_useropt
881      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
882      case $ac_user_opts in
# Line 1148 | Line 1080 | do
1080      ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1081      # Reject names that are not valid shell variable names.
1082      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1083 <      { $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1152 <   { (exit 1); exit 1; }; }
1083 >      as_fn_error $? "invalid package name: $ac_useropt"
1084      ac_useropt_orig=$ac_useropt
1085      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1086      case $ac_user_opts in
# Line 1165 | Line 1096 | do
1096      ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1097      # Reject names that are not valid shell variable names.
1098      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1099 <      { $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1169 <   { (exit 1); exit 1; }; }
1099 >      as_fn_error $? "invalid package name: $ac_useropt"
1100      ac_useropt_orig=$ac_useropt
1101      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1102      case $ac_user_opts in
# Line 1196 | Line 1126 | do
1126    | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1127      x_libraries=$ac_optarg ;;
1128  
1129 <  -*) { $as_echo "$as_me: error: unrecognized option: $ac_option
1130 < Try \`$0 --help' for more information." >&2
1201 <   { (exit 1); exit 1; }; }
1129 >  -*) as_fn_error $? "unrecognized option: \`$ac_option'
1130 > Try \`$0 --help' for more information"
1131      ;;
1132  
1133    *=*)
1134      ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1135      # Reject names that are not valid shell variable names.
1136 <    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
1137 <      { $as_echo "$as_me: error: invalid variable name: $ac_envvar" >&2
1138 <   { (exit 1); exit 1; }; }
1136 >    case $ac_envvar in #(
1137 >      '' | [0-9]* | *[!_$as_cr_alnum]* )
1138 >      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1139 >    esac
1140      eval $ac_envvar=\$ac_optarg
1141      export $ac_envvar ;;
1142  
# Line 1215 | Line 1145 | Try \`$0 --help' for more information." >&2
1145      $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1146      expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1147        $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1148 <    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
1148 >    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1149      ;;
1150  
1151    esac
# Line 1223 | Line 1153 | if test -n "$ac_prev"; then
1153  
1154   if test -n "$ac_prev"; then
1155    ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1156 <  { $as_echo "$as_me: error: missing argument to $ac_option" >&2
1227 <   { (exit 1); exit 1; }; }
1156 >  as_fn_error $? "missing argument to $ac_option"
1157   fi
1158  
1159   if test -n "$ac_unrecognized_opts"; then
1160    case $enable_option_checking in
1161      no) ;;
1162 <    fatal) { $as_echo "$as_me: error: Unrecognized options: $ac_unrecognized_opts" >&2
1163 <   { (exit 1); exit 1; }; } ;;
1235 <    *)     $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2 ;;
1162 >    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1163 >    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1164    esac
1165   fi
1166  
# Line 1254 | Line 1182 | do
1182      [\\/$]* | ?:[\\/]* )  continue;;
1183      NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1184    esac
1185 <  { $as_echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
1258 <   { (exit 1); exit 1; }; }
1185 >  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1186   done
1187  
1188   # There might be people who depend on the old broken behavior: `$host'
# Line 1269 | Line 1196 | if test "x$host_alias" != x; then
1196   if test "x$host_alias" != x; then
1197    if test "x$build_alias" = x; then
1198      cross_compiling=maybe
1199 <    $as_echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
1200 <    If a cross compiler is detected then cross compile mode will be used." >&2
1199 >    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
1200 >    If a cross compiler is detected then cross compile mode will be used" >&2
1201    elif test "x$build_alias" != "x$host_alias"; then
1202      cross_compiling=yes
1203    fi
# Line 1285 | Line 1212 | ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1212   ac_pwd=`pwd` && test -n "$ac_pwd" &&
1213   ac_ls_di=`ls -di .` &&
1214   ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1215 <  { $as_echo "$as_me: error: Working directory cannot be determined" >&2
1289 <   { (exit 1); exit 1; }; }
1215 >  as_fn_error $? "working directory cannot be determined"
1216   test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1217 <  { $as_echo "$as_me: error: pwd does not report name of working directory" >&2
1292 <   { (exit 1); exit 1; }; }
1217 >  as_fn_error $? "pwd does not report name of working directory"
1218  
1219  
1220   # Find the source files, if location was not specified.
# Line 1328 | Line 1253 | if test ! -r "$srcdir/$ac_unique_file"; then
1253   fi
1254   if test ! -r "$srcdir/$ac_unique_file"; then
1255    test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1256 <  { $as_echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
1332 <   { (exit 1); exit 1; }; }
1256 >  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1257   fi
1258   ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1259   ac_abs_confdir=`(
1260 <        cd "$srcdir" && test -r "./$ac_unique_file" || { $as_echo "$as_me: error: $ac_msg" >&2
1337 <   { (exit 1); exit 1; }; }
1260 >        cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1261          pwd)`
1262   # When building in place, set srcdir=.
1263   if test "$ac_abs_confdir" = "$ac_pwd"; then
# Line 1360 | Line 1283 | if test "$ac_init_help" = "long"; then
1283    # Omit some internal or obsolete options to make the list less imposing.
1284    # This message is too long to be a string in the A/UX 3.1 sh.
1285    cat <<_ACEOF
1286 < \`configure' configures OOPSE 4.0 to adapt to many kinds of systems.
1286 > \`configure' configures OpenMD 1.0 to adapt to many kinds of systems.
1287  
1288   Usage: $0 [OPTION]... [VAR=VALUE]...
1289  
# Line 1374 | Line 1297 | Configuration:
1297        --help=short        display options specific to this package
1298        --help=recursive    display the short help of all the included packages
1299    -V, --version           display version information and exit
1300 <  -q, --quiet, --silent   do not print \`checking...' messages
1300 >  -q, --quiet, --silent   do not print \`checking ...' messages
1301        --cache-file=FILE   cache test results in FILE [disabled]
1302    -C, --config-cache      alias for \`--cache-file=config.cache'
1303    -n, --no-create         do not create output files
# Line 1408 | Line 1331 | Fine tuning of the installation directories:
1331    --infodir=DIR           info documentation [DATAROOTDIR/info]
1332    --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1333    --mandir=DIR            man documentation [DATAROOTDIR/man]
1334 <  --docdir=DIR            documentation root [DATAROOTDIR/doc/oopse]
1334 >  --docdir=DIR            documentation root [DATAROOTDIR/doc/openmd]
1335    --htmldir=DIR           html documentation [DOCDIR]
1336    --dvidir=DIR            dvi documentation [DOCDIR]
1337    --pdfdir=DIR            pdf documentation [DOCDIR]
# Line 1425 | Line 1348 | if test -n "$ac_init_help"; then
1348  
1349   if test -n "$ac_init_help"; then
1350    case $ac_init_help in
1351 <     short | recursive ) echo "Configuration of OOPSE 4.0:";;
1351 >     short | recursive ) echo "Configuration of OpenMD 1.0:";;
1352     esac
1353    cat <<\_ACEOF
1354  
# Line 1433 | Line 1356 | Optional Features:
1356    --disable-option-checking  ignore unrecognized --enable/--with options
1357    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1358    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1359 <  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
1360 <  --enable-debug          Compile OOPSE in debug mode
1361 <  --enable-single         compile OOPSE in single precision
1359 >  --enable-openmd-home=DIR      define OpenMD home dir PREFIX/openmd
1360 >  --enable-debug          Compile OpenMD in debug mode
1361 >  --enable-single         compile OpenMD in single precision
1362    --enable-float          synonym for --enable-single
1363    --enable-doxygen        enable documentation generation with doxygen (auto)
1364    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
# Line 1445 | Line 1368 | Optional Packages:
1368   Optional Packages:
1369    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1370    --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]
1371    --with-perl-shebang     override what perl thinks is the way for the kernel
1372                            to start it (seldom needed)
1373    --with-zlib=DIR         root directory path of zlib installation (defaults
# Line 1459 | Line 1379 | Optional Packages:
1379    --with-openbabel=DIR    root directory path of openbabel-2.x installation
1380                            (defaults to /usr/local or /usr if not found in
1381                            /usr/local)
1462 –  --with-cgalmakefile=makefile
1463 –                          Use the following CGAL makefile
1382  
1383   Some influential environment variables:
1384    CXX         C++ compiler command
# Line 1468 | Line 1386 | Some influential environment variables:
1386    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1387                nonstandard directory <lib dir>
1388    LIBS        libraries to pass to the linker, e.g. -l<library>
1389 <  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1389 >  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1390                you have headers in a nonstandard directory <include dir>
1391    CC          C compiler command
1392    CFLAGS      C compiler flags
1393 <  FC          Fortran compiler command
1394 <  FCFLAGS     Fortran compiler flags
1393 >  MPICXX      MPI C++ compiler command
1394 >  MPICC       MPI C compiler command
1395    CPP         C preprocessor
1396    CXXCPP      C++ preprocessor
1397  
# Line 1543 | Line 1461 | if $ac_init_version; then
1461   test -n "$ac_init_help" && exit $ac_status
1462   if $ac_init_version; then
1463    cat <<\_ACEOF
1464 < OOPSE configure 4.0
1465 < generated by GNU Autoconf 2.62
1464 > OpenMD configure 1.0
1465 > generated by GNU Autoconf 2.68
1466  
1467 < Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1550 < 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
1467 > Copyright (C) 2010 Free Software Foundation, Inc.
1468   This configure script is free software; the Free Software Foundation
1469   gives unlimited permission to copy, distribute and modify it.
1470   _ACEOF
1471    exit
1472   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.
1473  
1474 < It was created by OOPSE $as_me 4.0, which was
1475 < generated by GNU Autoconf 2.62.  Invocation command line was
1474 > ## ------------------------ ##
1475 > ## Autoconf initialization. ##
1476 > ## ------------------------ ##
1477  
1478 <  $ $0 $@
1479 <
1480 < _ACEOF
1481 < exec 5>>config.log
1478 > # ac_fn_cxx_try_compile LINENO
1479 > # ----------------------------
1480 > # Try to compile conftest.$ac_ext, and return whether this succeeded.
1481 > ac_fn_cxx_try_compile ()
1482   {
1483 < cat <<_ASUNAME
1484 < ## --------- ##
1485 < ## Platform. ##
1486 < ## --------- ##
1483 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1484 >  rm -f conftest.$ac_objext
1485 >  if { { ac_try="$ac_compile"
1486 > case "(($ac_try" in
1487 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1488 >  *) ac_try_echo=$ac_try;;
1489 > esac
1490 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1491 > $as_echo "$ac_try_echo"; } >&5
1492 >  (eval "$ac_compile") 2>conftest.err
1493 >  ac_status=$?
1494 >  if test -s conftest.err; then
1495 >    grep -v '^ *+' conftest.err >conftest.er1
1496 >    cat conftest.er1 >&5
1497 >    mv -f conftest.er1 conftest.err
1498 >  fi
1499 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1500 >  test $ac_status = 0; } && {
1501 >         test -z "$ac_cxx_werror_flag" ||
1502 >         test ! -s conftest.err
1503 >       } && test -s conftest.$ac_objext; then :
1504 >  ac_retval=0
1505 > else
1506 >  $as_echo "$as_me: failed program was:" >&5
1507 > sed 's/^/| /' conftest.$ac_ext >&5
1508  
1509 < hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1510 < uname -m = `(uname -m) 2>/dev/null || echo unknown`
1511 < uname -r = `(uname -r) 2>/dev/null || echo unknown`
1512 < uname -s = `(uname -s) 2>/dev/null || echo unknown`
1577 < uname -v = `(uname -v) 2>/dev/null || echo unknown`
1509 >        ac_retval=1
1510 > fi
1511 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1512 >  as_fn_set_status $ac_retval
1513  
1514 + } # ac_fn_cxx_try_compile
1515 +
1516 + # ac_fn_c_try_compile LINENO
1517 + # --------------------------
1518 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1519 + ac_fn_c_try_compile ()
1520 + {
1521 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1522 +  rm -f conftest.$ac_objext
1523 +  if { { ac_try="$ac_compile"
1524 + case "(($ac_try" in
1525 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1526 +  *) ac_try_echo=$ac_try;;
1527 + esac
1528 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1529 + $as_echo "$ac_try_echo"; } >&5
1530 +  (eval "$ac_compile") 2>conftest.err
1531 +  ac_status=$?
1532 +  if test -s conftest.err; then
1533 +    grep -v '^ *+' conftest.err >conftest.er1
1534 +    cat conftest.er1 >&5
1535 +    mv -f conftest.er1 conftest.err
1536 +  fi
1537 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1538 +  test $ac_status = 0; } && {
1539 +         test -z "$ac_c_werror_flag" ||
1540 +         test ! -s conftest.err
1541 +       } && test -s conftest.$ac_objext; then :
1542 +  ac_retval=0
1543 + else
1544 +  $as_echo "$as_me: failed program was:" >&5
1545 + sed 's/^/| /' conftest.$ac_ext >&5
1546 +
1547 +        ac_retval=1
1548 + fi
1549 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1550 +  as_fn_set_status $ac_retval
1551 +
1552 + } # ac_fn_c_try_compile
1553 +
1554 + # ac_fn_cxx_try_link LINENO
1555 + # -------------------------
1556 + # Try to link conftest.$ac_ext, and return whether this succeeded.
1557 + ac_fn_cxx_try_link ()
1558 + {
1559 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1560 +  rm -f conftest.$ac_objext conftest$ac_exeext
1561 +  if { { ac_try="$ac_link"
1562 + case "(($ac_try" in
1563 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1564 +  *) ac_try_echo=$ac_try;;
1565 + esac
1566 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1567 + $as_echo "$ac_try_echo"; } >&5
1568 +  (eval "$ac_link") 2>conftest.err
1569 +  ac_status=$?
1570 +  if test -s conftest.err; then
1571 +    grep -v '^ *+' conftest.err >conftest.er1
1572 +    cat conftest.er1 >&5
1573 +    mv -f conftest.er1 conftest.err
1574 +  fi
1575 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1576 +  test $ac_status = 0; } && {
1577 +         test -z "$ac_cxx_werror_flag" ||
1578 +         test ! -s conftest.err
1579 +       } && test -s conftest$ac_exeext && {
1580 +         test "$cross_compiling" = yes ||
1581 +         $as_test_x conftest$ac_exeext
1582 +       }; then :
1583 +  ac_retval=0
1584 + else
1585 +  $as_echo "$as_me: failed program was:" >&5
1586 + sed 's/^/| /' conftest.$ac_ext >&5
1587 +
1588 +        ac_retval=1
1589 + fi
1590 +  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1591 +  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1592 +  # interfere with the next link command; also delete a directory that is
1593 +  # left behind by Apple's compiler.  We do this before executing the actions.
1594 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1595 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1596 +  as_fn_set_status $ac_retval
1597 +
1598 + } # ac_fn_cxx_try_link
1599 +
1600 + # ac_fn_cxx_check_func LINENO FUNC VAR
1601 + # ------------------------------------
1602 + # Tests whether FUNC exists, setting the cache variable VAR accordingly
1603 + ac_fn_cxx_check_func ()
1604 + {
1605 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1606 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1607 + $as_echo_n "checking for $2... " >&6; }
1608 + if eval \${$3+:} false; then :
1609 +  $as_echo_n "(cached) " >&6
1610 + else
1611 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1612 + /* end confdefs.h.  */
1613 + /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1614 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1615 + #define $2 innocuous_$2
1616 +
1617 + /* System header to define __stub macros and hopefully few prototypes,
1618 +    which can conflict with char $2 (); below.
1619 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1620 +    <limits.h> exists even on freestanding compilers.  */
1621 +
1622 + #ifdef __STDC__
1623 + # include <limits.h>
1624 + #else
1625 + # include <assert.h>
1626 + #endif
1627 +
1628 + #undef $2
1629 +
1630 + /* Override any GCC internal prototype to avoid an error.
1631 +   Use char because int might match the return type of a GCC
1632 +   builtin and then its argument prototype would still apply.  */
1633 + #ifdef __cplusplus
1634 + extern "C"
1635 + #endif
1636 + char $2 ();
1637 + /* The GNU C library defines this for functions which it implements
1638 +    to always fail with ENOSYS.  Some functions are actually named
1639 +    something starting with __ and the normal name is an alias.  */
1640 + #if defined __stub_$2 || defined __stub___$2
1641 + choke me
1642 + #endif
1643 +
1644 + int
1645 + main ()
1646 + {
1647 + return $2 ();
1648 +  ;
1649 +  return 0;
1650 + }
1651 + _ACEOF
1652 + if ac_fn_cxx_try_link "$LINENO"; then :
1653 +  eval "$3=yes"
1654 + else
1655 +  eval "$3=no"
1656 + fi
1657 + rm -f core conftest.err conftest.$ac_objext \
1658 +    conftest$ac_exeext conftest.$ac_ext
1659 + fi
1660 + eval ac_res=\$$3
1661 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1662 + $as_echo "$ac_res" >&6; }
1663 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1664 +
1665 + } # ac_fn_cxx_check_func
1666 +
1667 + # ac_fn_c_try_link LINENO
1668 + # -----------------------
1669 + # Try to link conftest.$ac_ext, and return whether this succeeded.
1670 + ac_fn_c_try_link ()
1671 + {
1672 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1673 +  rm -f conftest.$ac_objext conftest$ac_exeext
1674 +  if { { ac_try="$ac_link"
1675 + case "(($ac_try" in
1676 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1677 +  *) ac_try_echo=$ac_try;;
1678 + esac
1679 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1680 + $as_echo "$ac_try_echo"; } >&5
1681 +  (eval "$ac_link") 2>conftest.err
1682 +  ac_status=$?
1683 +  if test -s conftest.err; then
1684 +    grep -v '^ *+' conftest.err >conftest.er1
1685 +    cat conftest.er1 >&5
1686 +    mv -f conftest.er1 conftest.err
1687 +  fi
1688 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1689 +  test $ac_status = 0; } && {
1690 +         test -z "$ac_c_werror_flag" ||
1691 +         test ! -s conftest.err
1692 +       } && test -s conftest$ac_exeext && {
1693 +         test "$cross_compiling" = yes ||
1694 +         $as_test_x conftest$ac_exeext
1695 +       }; then :
1696 +  ac_retval=0
1697 + else
1698 +  $as_echo "$as_me: failed program was:" >&5
1699 + sed 's/^/| /' conftest.$ac_ext >&5
1700 +
1701 +        ac_retval=1
1702 + fi
1703 +  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1704 +  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1705 +  # interfere with the next link command; also delete a directory that is
1706 +  # left behind by Apple's compiler.  We do this before executing the actions.
1707 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1708 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1709 +  as_fn_set_status $ac_retval
1710 +
1711 + } # ac_fn_c_try_link
1712 +
1713 + # ac_fn_c_check_func LINENO FUNC VAR
1714 + # ----------------------------------
1715 + # Tests whether FUNC exists, setting the cache variable VAR accordingly
1716 + ac_fn_c_check_func ()
1717 + {
1718 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1719 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1720 + $as_echo_n "checking for $2... " >&6; }
1721 + if eval \${$3+:} false; then :
1722 +  $as_echo_n "(cached) " >&6
1723 + else
1724 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1725 + /* end confdefs.h.  */
1726 + /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1727 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1728 + #define $2 innocuous_$2
1729 +
1730 + /* System header to define __stub macros and hopefully few prototypes,
1731 +    which can conflict with char $2 (); below.
1732 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1733 +    <limits.h> exists even on freestanding compilers.  */
1734 +
1735 + #ifdef __STDC__
1736 + # include <limits.h>
1737 + #else
1738 + # include <assert.h>
1739 + #endif
1740 +
1741 + #undef $2
1742 +
1743 + /* Override any GCC internal prototype to avoid an error.
1744 +   Use char because int might match the return type of a GCC
1745 +   builtin and then its argument prototype would still apply.  */
1746 + #ifdef __cplusplus
1747 + extern "C"
1748 + #endif
1749 + char $2 ();
1750 + /* The GNU C library defines this for functions which it implements
1751 +    to always fail with ENOSYS.  Some functions are actually named
1752 +    something starting with __ and the normal name is an alias.  */
1753 + #if defined __stub_$2 || defined __stub___$2
1754 + choke me
1755 + #endif
1756 +
1757 + int
1758 + main ()
1759 + {
1760 + return $2 ();
1761 +  ;
1762 +  return 0;
1763 + }
1764 + _ACEOF
1765 + if ac_fn_c_try_link "$LINENO"; then :
1766 +  eval "$3=yes"
1767 + else
1768 +  eval "$3=no"
1769 + fi
1770 + rm -f core conftest.err conftest.$ac_objext \
1771 +    conftest$ac_exeext conftest.$ac_ext
1772 + fi
1773 + eval ac_res=\$$3
1774 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1775 + $as_echo "$ac_res" >&6; }
1776 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1777 +
1778 + } # ac_fn_c_check_func
1779 +
1780 + # ac_fn_c_try_cpp LINENO
1781 + # ----------------------
1782 + # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1783 + ac_fn_c_try_cpp ()
1784 + {
1785 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1786 +  if { { ac_try="$ac_cpp conftest.$ac_ext"
1787 + case "(($ac_try" in
1788 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1789 +  *) ac_try_echo=$ac_try;;
1790 + esac
1791 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1792 + $as_echo "$ac_try_echo"; } >&5
1793 +  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1794 +  ac_status=$?
1795 +  if test -s conftest.err; then
1796 +    grep -v '^ *+' conftest.err >conftest.er1
1797 +    cat conftest.er1 >&5
1798 +    mv -f conftest.er1 conftest.err
1799 +  fi
1800 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1801 +  test $ac_status = 0; } > conftest.i && {
1802 +         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
1803 +         test ! -s conftest.err
1804 +       }; then :
1805 +  ac_retval=0
1806 + else
1807 +  $as_echo "$as_me: failed program was:" >&5
1808 + sed 's/^/| /' conftest.$ac_ext >&5
1809 +
1810 +    ac_retval=1
1811 + fi
1812 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1813 +  as_fn_set_status $ac_retval
1814 +
1815 + } # ac_fn_c_try_cpp
1816 +
1817 + # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1818 + # -------------------------------------------------------
1819 + # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1820 + # the include files in INCLUDES and setting the cache variable VAR
1821 + # accordingly.
1822 + ac_fn_c_check_header_mongrel ()
1823 + {
1824 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1825 +  if eval \${$3+:} false; then :
1826 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1827 + $as_echo_n "checking for $2... " >&6; }
1828 + if eval \${$3+:} false; then :
1829 +  $as_echo_n "(cached) " >&6
1830 + fi
1831 + eval ac_res=\$$3
1832 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1833 + $as_echo "$ac_res" >&6; }
1834 + else
1835 +  # Is the header compilable?
1836 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1837 + $as_echo_n "checking $2 usability... " >&6; }
1838 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1839 + /* end confdefs.h.  */
1840 + $4
1841 + #include <$2>
1842 + _ACEOF
1843 + if ac_fn_c_try_compile "$LINENO"; then :
1844 +  ac_header_compiler=yes
1845 + else
1846 +  ac_header_compiler=no
1847 + fi
1848 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1849 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1850 + $as_echo "$ac_header_compiler" >&6; }
1851 +
1852 + # Is the header present?
1853 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1854 + $as_echo_n "checking $2 presence... " >&6; }
1855 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1856 + /* end confdefs.h.  */
1857 + #include <$2>
1858 + _ACEOF
1859 + if ac_fn_c_try_cpp "$LINENO"; then :
1860 +  ac_header_preproc=yes
1861 + else
1862 +  ac_header_preproc=no
1863 + fi
1864 + rm -f conftest.err conftest.i conftest.$ac_ext
1865 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1866 + $as_echo "$ac_header_preproc" >&6; }
1867 +
1868 + # So?  What about this header?
1869 + case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1870 +  yes:no: )
1871 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1872 + $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1873 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1874 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1875 +    ;;
1876 +  no:yes:* )
1877 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1878 + $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1879 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1880 + $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1881 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1882 + $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1883 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1884 + $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1885 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1886 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1887 + ( $as_echo "## ------------------------------ ##
1888 + ## Report this to gezelter@nd.edu ##
1889 + ## ------------------------------ ##"
1890 +     ) | sed "s/^/$as_me: WARNING:     /" >&2
1891 +    ;;
1892 + esac
1893 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1894 + $as_echo_n "checking for $2... " >&6; }
1895 + if eval \${$3+:} false; then :
1896 +  $as_echo_n "(cached) " >&6
1897 + else
1898 +  eval "$3=\$ac_header_compiler"
1899 + fi
1900 + eval ac_res=\$$3
1901 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1902 + $as_echo "$ac_res" >&6; }
1903 + fi
1904 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1905 +
1906 + } # ac_fn_c_check_header_mongrel
1907 +
1908 + # ac_fn_c_try_run LINENO
1909 + # ----------------------
1910 + # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
1911 + # that executables *can* be run.
1912 + ac_fn_c_try_run ()
1913 + {
1914 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1915 +  if { { ac_try="$ac_link"
1916 + case "(($ac_try" in
1917 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1918 +  *) ac_try_echo=$ac_try;;
1919 + esac
1920 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1921 + $as_echo "$ac_try_echo"; } >&5
1922 +  (eval "$ac_link") 2>&5
1923 +  ac_status=$?
1924 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1925 +  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
1926 +  { { case "(($ac_try" in
1927 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1928 +  *) ac_try_echo=$ac_try;;
1929 + esac
1930 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1931 + $as_echo "$ac_try_echo"; } >&5
1932 +  (eval "$ac_try") 2>&5
1933 +  ac_status=$?
1934 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1935 +  test $ac_status = 0; }; }; then :
1936 +  ac_retval=0
1937 + else
1938 +  $as_echo "$as_me: program exited with status $ac_status" >&5
1939 +       $as_echo "$as_me: failed program was:" >&5
1940 + sed 's/^/| /' conftest.$ac_ext >&5
1941 +
1942 +       ac_retval=$ac_status
1943 + fi
1944 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1945 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1946 +  as_fn_set_status $ac_retval
1947 +
1948 + } # ac_fn_c_try_run
1949 +
1950 + # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
1951 + # -------------------------------------------------------
1952 + # Tests whether HEADER exists and can be compiled using the include files in
1953 + # INCLUDES, setting the cache variable VAR accordingly.
1954 + ac_fn_c_check_header_compile ()
1955 + {
1956 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1957 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1958 + $as_echo_n "checking for $2... " >&6; }
1959 + if eval \${$3+:} false; then :
1960 +  $as_echo_n "(cached) " >&6
1961 + else
1962 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1963 + /* end confdefs.h.  */
1964 + $4
1965 + #include <$2>
1966 + _ACEOF
1967 + if ac_fn_c_try_compile "$LINENO"; then :
1968 +  eval "$3=yes"
1969 + else
1970 +  eval "$3=no"
1971 + fi
1972 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1973 + fi
1974 + eval ac_res=\$$3
1975 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1976 + $as_echo "$ac_res" >&6; }
1977 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1978 +
1979 + } # ac_fn_c_check_header_compile
1980 +
1981 + # ac_fn_cxx_try_cpp LINENO
1982 + # ------------------------
1983 + # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1984 + ac_fn_cxx_try_cpp ()
1985 + {
1986 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1987 +  if { { ac_try="$ac_cpp conftest.$ac_ext"
1988 + case "(($ac_try" in
1989 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1990 +  *) ac_try_echo=$ac_try;;
1991 + esac
1992 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1993 + $as_echo "$ac_try_echo"; } >&5
1994 +  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1995 +  ac_status=$?
1996 +  if test -s conftest.err; then
1997 +    grep -v '^ *+' conftest.err >conftest.er1
1998 +    cat conftest.er1 >&5
1999 +    mv -f conftest.er1 conftest.err
2000 +  fi
2001 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2002 +  test $ac_status = 0; } > conftest.i && {
2003 +         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2004 +         test ! -s conftest.err
2005 +       }; then :
2006 +  ac_retval=0
2007 + else
2008 +  $as_echo "$as_me: failed program was:" >&5
2009 + sed 's/^/| /' conftest.$ac_ext >&5
2010 +
2011 +    ac_retval=1
2012 + fi
2013 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2014 +  as_fn_set_status $ac_retval
2015 +
2016 + } # ac_fn_cxx_try_cpp
2017 +
2018 + # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2019 + # ---------------------------------------------------------
2020 + # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2021 + # the include files in INCLUDES and setting the cache variable VAR
2022 + # accordingly.
2023 + ac_fn_cxx_check_header_mongrel ()
2024 + {
2025 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2026 +  if eval \${$3+:} false; then :
2027 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2028 + $as_echo_n "checking for $2... " >&6; }
2029 + if eval \${$3+:} false; then :
2030 +  $as_echo_n "(cached) " >&6
2031 + fi
2032 + eval ac_res=\$$3
2033 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2034 + $as_echo "$ac_res" >&6; }
2035 + else
2036 +  # Is the header compilable?
2037 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2038 + $as_echo_n "checking $2 usability... " >&6; }
2039 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2040 + /* end confdefs.h.  */
2041 + $4
2042 + #include <$2>
2043 + _ACEOF
2044 + if ac_fn_cxx_try_compile "$LINENO"; then :
2045 +  ac_header_compiler=yes
2046 + else
2047 +  ac_header_compiler=no
2048 + fi
2049 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2050 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2051 + $as_echo "$ac_header_compiler" >&6; }
2052 +
2053 + # Is the header present?
2054 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2055 + $as_echo_n "checking $2 presence... " >&6; }
2056 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2057 + /* end confdefs.h.  */
2058 + #include <$2>
2059 + _ACEOF
2060 + if ac_fn_cxx_try_cpp "$LINENO"; then :
2061 +  ac_header_preproc=yes
2062 + else
2063 +  ac_header_preproc=no
2064 + fi
2065 + rm -f conftest.err conftest.i conftest.$ac_ext
2066 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2067 + $as_echo "$ac_header_preproc" >&6; }
2068 +
2069 + # So?  What about this header?
2070 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2071 +  yes:no: )
2072 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2073 + $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2074 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2075 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2076 +    ;;
2077 +  no:yes:* )
2078 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2079 + $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2080 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2081 + $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2082 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2083 + $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2084 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2085 + $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2086 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2087 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2088 + ( $as_echo "## ------------------------------ ##
2089 + ## Report this to gezelter@nd.edu ##
2090 + ## ------------------------------ ##"
2091 +     ) | sed "s/^/$as_me: WARNING:     /" >&2
2092 +    ;;
2093 + esac
2094 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2095 + $as_echo_n "checking for $2... " >&6; }
2096 + if eval \${$3+:} false; then :
2097 +  $as_echo_n "(cached) " >&6
2098 + else
2099 +  eval "$3=\$ac_header_compiler"
2100 + fi
2101 + eval ac_res=\$$3
2102 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2103 + $as_echo "$ac_res" >&6; }
2104 + fi
2105 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2106 +
2107 + } # ac_fn_cxx_check_header_mongrel
2108 +
2109 + # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
2110 + # -------------------------------------------
2111 + # Tests whether TYPE exists after having included INCLUDES, setting cache
2112 + # variable VAR accordingly.
2113 + ac_fn_c_check_type ()
2114 + {
2115 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2116 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2117 + $as_echo_n "checking for $2... " >&6; }
2118 + if eval \${$3+:} false; then :
2119 +  $as_echo_n "(cached) " >&6
2120 + else
2121 +  eval "$3=no"
2122 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2123 + /* end confdefs.h.  */
2124 + $4
2125 + int
2126 + main ()
2127 + {
2128 + if (sizeof ($2))
2129 +         return 0;
2130 +  ;
2131 +  return 0;
2132 + }
2133 + _ACEOF
2134 + if ac_fn_c_try_compile "$LINENO"; then :
2135 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2136 + /* end confdefs.h.  */
2137 + $4
2138 + int
2139 + main ()
2140 + {
2141 + if (sizeof (($2)))
2142 +            return 0;
2143 +  ;
2144 +  return 0;
2145 + }
2146 + _ACEOF
2147 + if ac_fn_c_try_compile "$LINENO"; then :
2148 +
2149 + else
2150 +  eval "$3=yes"
2151 + fi
2152 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2153 + fi
2154 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2155 + fi
2156 + eval ac_res=\$$3
2157 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2158 + $as_echo "$ac_res" >&6; }
2159 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2160 +
2161 + } # ac_fn_c_check_type
2162 + cat >config.log <<_ACEOF
2163 + This file contains any messages produced by compilers while
2164 + running configure, to aid debugging if configure makes a mistake.
2165 +
2166 + It was created by OpenMD $as_me 1.0, which was
2167 + generated by GNU Autoconf 2.68.  Invocation command line was
2168 +
2169 +  $ $0 $@
2170 +
2171 + _ACEOF
2172 + exec 5>>config.log
2173 + {
2174 + cat <<_ASUNAME
2175 + ## --------- ##
2176 + ## Platform. ##
2177 + ## --------- ##
2178 +
2179 + hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2180 + uname -m = `(uname -m) 2>/dev/null || echo unknown`
2181 + uname -r = `(uname -r) 2>/dev/null || echo unknown`
2182 + uname -s = `(uname -s) 2>/dev/null || echo unknown`
2183 + uname -v = `(uname -v) 2>/dev/null || echo unknown`
2184 +
2185   /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2186   /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2187  
# Line 1594 | Line 2200 | do
2200   do
2201    IFS=$as_save_IFS
2202    test -z "$as_dir" && as_dir=.
2203 <  $as_echo "PATH: $as_dir"
2204 < done
2203 >    $as_echo "PATH: $as_dir"
2204 >  done
2205   IFS=$as_save_IFS
2206  
2207   } >&5
# Line 1632 | Line 2238 | do
2238        ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2239      esac
2240      case $ac_pass in
2241 <    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
2241 >    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2242      2)
2243 <      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
2243 >      as_fn_append ac_configure_args1 " '$ac_arg'"
2244        if test $ac_must_keep_next = true; then
2245          ac_must_keep_next=false # Got value, back to normal.
2246        else
# Line 1650 | Line 2256 | do
2256            -* ) ac_must_keep_next=true ;;
2257          esac
2258        fi
2259 <      ac_configure_args="$ac_configure_args '$ac_arg'"
2259 >      as_fn_append ac_configure_args " '$ac_arg'"
2260        ;;
2261      esac
2262    done
2263   done
2264 < $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
2265 < $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
2264 > { ac_configure_args0=; unset ac_configure_args0;}
2265 > { ac_configure_args1=; unset ac_configure_args1;}
2266  
2267   # When interrupted or exit'd, cleanup temporary files, and complete
2268   # config.log.  We remove comments because anyway the quotes in there
# Line 1668 | Line 2274 | trap 'exit_status=$?
2274    {
2275      echo
2276  
2277 <    cat <<\_ASBOX
1672 < ## ---------------- ##
2277 >    $as_echo "## ---------------- ##
2278   ## Cache variables. ##
2279 < ## ---------------- ##
1675 < _ASBOX
2279 > ## ---------------- ##"
2280      echo
2281      # The following way of writing the cache mishandles newlines in values,
2282   (
# Line 1681 | Line 2285 | _ASBOX
2285      case $ac_val in #(
2286      *${as_nl}*)
2287        case $ac_var in #(
2288 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
2289 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
2288 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2289 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2290        esac
2291        case $ac_var in #(
2292        _ | IFS | as_nl) ;; #(
2293        BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2294 <      *) $as_unset $ac_var ;;
2294 >      *) { eval $ac_var=; unset $ac_var;} ;;
2295        esac ;;
2296      esac
2297    done
# Line 1706 | Line 2310 | $as_echo "$as_me: WARNING: Cache variable $ac_var cont
2310   )
2311      echo
2312  
2313 <    cat <<\_ASBOX
1710 < ## ----------------- ##
2313 >    $as_echo "## ----------------- ##
2314   ## Output variables. ##
2315 < ## ----------------- ##
1713 < _ASBOX
2315 > ## ----------------- ##"
2316      echo
2317      for ac_var in $ac_subst_vars
2318      do
# Line 1723 | Line 2325 | _ASBOX
2325      echo
2326  
2327      if test -n "$ac_subst_files"; then
2328 <      cat <<\_ASBOX
1727 < ## ------------------- ##
2328 >      $as_echo "## ------------------- ##
2329   ## File substitutions. ##
2330 < ## ------------------- ##
1730 < _ASBOX
2330 > ## ------------------- ##"
2331        echo
2332        for ac_var in $ac_subst_files
2333        do
# Line 1741 | Line 2341 | _ASBOX
2341      fi
2342  
2343      if test -s confdefs.h; then
2344 <      cat <<\_ASBOX
1745 < ## ----------- ##
2344 >      $as_echo "## ----------- ##
2345   ## confdefs.h. ##
2346 < ## ----------- ##
1748 < _ASBOX
2346 > ## ----------- ##"
2347        echo
2348        cat confdefs.h
2349        echo
# Line 1759 | Line 2357 | for ac_signal in 1 2 13 15; do
2357      exit $exit_status
2358   ' 0
2359   for ac_signal in 1 2 13 15; do
2360 <  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
2360 >  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2361   done
2362   ac_signal=0
2363  
2364   # confdefs.h avoids OS command line length limits that DEFS can exceed.
2365   rm -f -r conftest* confdefs.h
2366  
2367 + $as_echo "/* confdefs.h */" > confdefs.h
2368 +
2369   # Predefined preprocessor variables.
2370  
2371   cat >>confdefs.h <<_ACEOF
2372   #define PACKAGE_NAME "$PACKAGE_NAME"
2373   _ACEOF
2374  
1775 –
2375   cat >>confdefs.h <<_ACEOF
2376   #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
2377   _ACEOF
2378  
1780 –
2379   cat >>confdefs.h <<_ACEOF
2380   #define PACKAGE_VERSION "$PACKAGE_VERSION"
2381   _ACEOF
2382  
1785 –
2383   cat >>confdefs.h <<_ACEOF
2384   #define PACKAGE_STRING "$PACKAGE_STRING"
2385   _ACEOF
2386  
1790 –
2387   cat >>confdefs.h <<_ACEOF
2388   #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
2389 + _ACEOF
2390 +
2391 + cat >>confdefs.h <<_ACEOF
2392 + #define PACKAGE_URL "$PACKAGE_URL"
2393   _ACEOF
2394  
2395  
# Line 1798 | Line 2398 | if test -n "$CONFIG_SITE"; then
2398   ac_site_file1=NONE
2399   ac_site_file2=NONE
2400   if test -n "$CONFIG_SITE"; then
2401 <  ac_site_file1=$CONFIG_SITE
2401 >  # We do not want a PATH search for config.site.
2402 >  case $CONFIG_SITE in #((
2403 >    -*)  ac_site_file1=./$CONFIG_SITE;;
2404 >    */*) ac_site_file1=$CONFIG_SITE;;
2405 >    *)   ac_site_file1=./$CONFIG_SITE;;
2406 >  esac
2407   elif test "x$prefix" != xNONE; then
2408    ac_site_file1=$prefix/share/config.site
2409    ac_site_file2=$prefix/etc/config.site
# Line 1809 | Line 2414 | do
2414   for ac_site_file in "$ac_site_file1" "$ac_site_file2"
2415   do
2416    test "x$ac_site_file" = xNONE && continue
2417 <  if test -r "$ac_site_file"; then
2418 <    { $as_echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
2417 >  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
2418 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2419   $as_echo "$as_me: loading site script $ac_site_file" >&6;}
2420      sed 's/^/| /' "$ac_site_file" >&5
2421 <    . "$ac_site_file"
2421 >    . "$ac_site_file" \
2422 >      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2423 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2424 > as_fn_error $? "failed to load site script $ac_site_file
2425 > See \`config.log' for more details" "$LINENO" 5; }
2426    fi
2427   done
2428  
2429   if test -r "$cache_file"; then
2430 <  # Some versions of bash will fail to source /dev/null (special
2431 <  # files actually), so we avoid doing that.
2432 <  if test -f "$cache_file"; then
2433 <    { $as_echo "$as_me:$LINENO: loading cache $cache_file" >&5
2430 >  # Some versions of bash will fail to source /dev/null (special files
2431 >  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
2432 >  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
2433 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2434   $as_echo "$as_me: loading cache $cache_file" >&6;}
2435      case $cache_file in
2436        [\\/]* | ?:[\\/]* ) . "$cache_file";;
# Line 1829 | Line 2438 | else
2438      esac
2439    fi
2440   else
2441 <  { $as_echo "$as_me:$LINENO: creating cache $cache_file" >&5
2441 >  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
2442   $as_echo "$as_me: creating cache $cache_file" >&6;}
2443    >$cache_file
2444   fi
# Line 1844 | Line 2453 | for ac_var in $ac_precious_vars; do
2453    eval ac_new_val=\$ac_env_${ac_var}_value
2454    case $ac_old_set,$ac_new_set in
2455      set,)
2456 <      { $as_echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2456 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2457   $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2458        ac_cache_corrupted=: ;;
2459      ,set)
2460 <      { $as_echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
2460 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
2461   $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2462        ac_cache_corrupted=: ;;
2463      ,);;
# Line 1858 | Line 2467 | $as_echo "$as_me: error: \`$ac_var' was not set in the
2467          ac_old_val_w=`echo x $ac_old_val`
2468          ac_new_val_w=`echo x $ac_new_val`
2469          if test "$ac_old_val_w" != "$ac_new_val_w"; then
2470 <          { $as_echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
2470 >          { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
2471   $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2472            ac_cache_corrupted=:
2473          else
2474 <          { $as_echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2474 >          { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2475   $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
2476            eval $ac_var=\$ac_old_val
2477          fi
2478 <        { $as_echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
2478 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
2479   $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
2480 <        { $as_echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
2480 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
2481   $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
2482        fi;;
2483    esac
# Line 1880 | Line 2489 | $as_echo "$as_me:   current value: \`$ac_new_val'" >&2
2489      esac
2490      case " $ac_configure_args " in
2491        *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
2492 <      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
2492 >      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
2493      esac
2494    fi
2495   done
2496   if $ac_cache_corrupted; then
2497 <  { $as_echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
2497 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2498 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2499 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
2500   $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2501 <  { { $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; }; }
2501 >  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
2502   fi
2503 <
2504 <
2505 <
1897 <
1898 <
1899 <
2503 > ## -------------------- ##
2504 > ## Main body of script. ##
2505 > ## -------------------- ##
2506  
1901 –
1902 –
1903 –
1904 –
1905 –
1906 –
1907 –
1908 –
1909 –
1910 –
1911 –
1912 –
1913 –
1914 –
1915 –
1916 –
1917 –
1918 –
2507   ac_ext=c
2508   ac_cpp='$CPP $CPPFLAGS'
2509   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 1940 | Line 2528 | if test -z "$ac_aux_dir"; then
2528    fi
2529   done
2530   if test -z "$ac_aux_dir"; then
2531 <  { { $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; }; }
2531 >  as_fn_error $? "cannot find install-sh, install.sh, or shtool in ac-tools \"$srcdir\"/ac-tools" "$LINENO" 5
2532   fi
2533  
2534   # These three variables are undocumented and unsupported,
# Line 1985 | Line 2571 | ac_config_headers="$ac_config_headers src/config.h"
2571  
2572  
2573  
1988 –
1989 –
1990 –
1991 –
1992 –
1993 –
1994 –
1995 –
1996 –
1997 –
1998 –
1999 –
2000 –
2001 –
2002 –
2574   #
2575   #
2576   #
# Line 2013 | Line 2584 | ac_config_headers="$ac_config_headers src/config.h"
2584  
2585  
2586  
2016 – # AC_F90_MODULE_NAMES
2017 – # -------------------
2018 – #
2019 – # Figure out how the Fortran 90 compiler constructs module file names
2020 – #
2021 – # AC_F90_MODULE_NAMES
2587  
2588  
2589  
# Line 2106 | Line 2671 | ac_config_headers="$ac_config_headers src/config.h"
2671  
2672  
2673  
2674 < # ACX_MPI_GET_PROG
2675 <
2676 < # ACX_DETECT_MPI_IMPLEMENTATION
2677 <
2678 <
2679 <
2680 <
2681 <
2682 < # ACX_MPI
2683 <
2684 <
2685 <
2686 <
2687 <
2688 <
2689 <
2690 <
2691 <
2692 <
2693 <
2694 <
2695 <
2696 <
2697 <
2698 <
2699 <
2700 <
2701 <
2702 <
2703 <
2704 <
2705 <
2706 <
2707 <
2708 <
2709 <
2710 < # This is taken from http://autoqt.sourceforge.net/
2711 < # Copyright (c) 2002, Geoffrey Wossum
2712 < # All rights reserved.
2713 <
2714 < # Redistribution and use in source and binary forms, with or without
2715 < # modification, are permitted provided that the following conditions are
2716 < # met:
2717 <
2718 < #  - Redistributions of source code must retain the above copyright notice,
2719 < #    this list of conditions and the following disclaimer.
2720 <
2721 < #  - Redistributions in binary form must reproduce the above copyright
2722 < #    notice, this list of conditions and the following disclaimer in the
2723 < #    documentation and/or other materials provided with the distribution.
2674 > # ===========================================================================
2675 > #             http://www.nongnu.org/autoconf-archive/ax_mpi.html
2676 > # ===========================================================================
2677 > #
2678 > # SYNOPSIS
2679 > #
2680 > #   AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
2681 > #
2682 > # DESCRIPTION
2683 > #
2684 > #   This macro tries to find out how to compile programs that use MPI
2685 > #   (Message Passing Interface), a standard API for parallel process
2686 > #   communication (see http://www-unix.mcs.anl.gov/mpi/)
2687 > #
2688 > #   On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
2689 > #   to the name of the MPI compiler, depending upon the current language.
2690 > #   (This may just be $CC/$CXX/$F77/$FC, but is more often something like
2691 > #   mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
2692 > #   are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
2693 > #   MPICC/MPICXX/MPIF77/MPIFC was not found).
2694 > #
2695 > #   If you want to compile everything with MPI, you should set:
2696 > #
2697 > #       CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
2698 > #       LIBS="$MPILIBS $LIBS"
2699 > #
2700 > #   NOTE: The above assumes that you will use $CC (or whatever) for linking
2701 > #   as well as for compiling. (This is the default for automake and most
2702 > #   Makefiles.)
2703 > #
2704 > #   The user can force a particular library/compiler by setting the
2705 > #   MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
2706 > #
2707 > #   ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
2708 > #   found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
2709 > #   found. If ACTION-IF-FOUND is not specified, the default action will
2710 > #   define HAVE_MPI.
2711 > #
2712 > # LICENSE
2713 > #
2714 > #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2715 > #   Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
2716 > #
2717 > #   This program is free software: you can redistribute it and/or modify it
2718 > #   under the terms of the GNU General Public License as published by the
2719 > #   Free Software Foundation, either version 3 of the License, or (at your
2720 > #   option) any later version.
2721 > #
2722 > #   This program is distributed in the hope that it will be useful, but
2723 > #   WITHOUT ANY WARRANTY; without even the implied warranty of
2724 > #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2725 > #   Public License for more details.
2726 > #
2727 > #   You should have received a copy of the GNU General Public License along
2728 > #   with this program. If not, see <http://www.gnu.org/licenses/>.
2729 > #
2730 > #   As a special exception, the respective Autoconf Macro's copyright owner
2731 > #   gives unlimited permission to copy, distribute and modify the configure
2732 > #   scripts that are the output of Autoconf when processing the Macro. You
2733 > #   need not follow the terms of the GNU General Public License when using
2734 > #   or distributing such scripts, even though portions of the text of the
2735 > #   Macro appear in them. The GNU General Public License (GPL) does govern
2736 > #   all other use of the material that constitutes the Autoconf Macro.
2737 > #
2738 > #   This special exception to the GPL applies to versions of the Autoconf
2739 > #   Macro released by the Autoconf Archive. When you make and distribute a
2740 > #   modified version of the Autoconf Macro, you may extend this special
2741 > #   exception to the GPL to apply to your modified version as well.
2742  
2743 < #  - Neither the name of Geoffrey Wossum nor the names of its
2744 < #    contributors may be used to endorse or promote products derived from
2745 < #    this software without specific prior written permission.
2743 > # This is what autoupdate's m4 run will expand.  It fires
2744 > # the warning (with _au_warn_XXX), outputs it into the
2745 > # updated configure.ac (with AC_DIAGNOSE), and then outputs
2746 > # the replacement expansion.
2747  
2748  
2749 < # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2750 < # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
2751 < # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2752 < # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
2753 < # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
2170 < # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
2171 < # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
2172 < # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
2173 < # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
2174 < # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
2175 < # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2749 > # This is an auxiliary macro that is also run when
2750 > # autoupdate runs m4.  It simply calls m4_warning, but
2751 > # we need a wrapper so that each warning is emitted only
2752 > # once.  We break the quoting in m4_warning's argument in
2753 > # order to expand this macro's arguments, not AU_DEFUN's.
2754  
2755  
2756 < # Check for Qt compiler flags, linker flags, and binary packages
2756 > # Finally, this is the expansion that is picked up by
2757 > # autoconf.  It tells the user to run autoupdate, and
2758 > # then outputs the replacement expansion.  We do not care
2759 > # about autoupdate's warning because that contains
2760 > # information on what to do *after* running autoupdate.
2761  
2762  
2763  
2764   # who am i
2765   # Make sure we can run config.sub.
2766   $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
2767 <  { { $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; }; }
2767 >  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2768  
2769 < { $as_echo "$as_me:$LINENO: checking build system type" >&5
2769 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2770   $as_echo_n "checking build system type... " >&6; }
2771 < if test "${ac_cv_build+set}" = set; then
2771 > if ${ac_cv_build+:} false; then :
2772    $as_echo_n "(cached) " >&6
2773   else
2774    ac_build_alias=$build_alias
2775   test "x$ac_build_alias" = x &&
2776    ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2777   test "x$ac_build_alias" = x &&
2778 <  { { $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; }; }
2778 >  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
2779   ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
2780 <  { { $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; }; }
2780 >  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2781  
2782   fi
2783 < { $as_echo "$as_me:$LINENO: result: $ac_cv_build" >&5
2783 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2784   $as_echo "$ac_cv_build" >&6; }
2785   case $ac_cv_build in
2786   *-*-*) ;;
2787 < *) { { $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; }; };;
2787 > *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
2788   esac
2789   build=$ac_cv_build
2790   ac_save_IFS=$IFS; IFS='-'
# Line 2226 | Line 2800 | case $build_os in *\ *) build_os=`echo "$build_os" | s
2800   case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
2801  
2802  
2803 < { $as_echo "$as_me:$LINENO: checking host system type" >&5
2803 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
2804   $as_echo_n "checking host system type... " >&6; }
2805 < if test "${ac_cv_host+set}" = set; then
2805 > if ${ac_cv_host+:} false; then :
2806    $as_echo_n "(cached) " >&6
2807   else
2808    if test "x$host_alias" = x; then
2809    ac_cv_host=$ac_cv_build
2810   else
2811    ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
2812 <    { { $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; }; }
2812 >    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
2813   fi
2814  
2815   fi
2816 < { $as_echo "$as_me:$LINENO: result: $ac_cv_host" >&5
2816 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
2817   $as_echo "$ac_cv_host" >&6; }
2818   case $ac_cv_host in
2819   *-*-*) ;;
2820 < *) { { $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; }; };;
2820 > *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
2821   esac
2822   host=$ac_cv_host
2823   ac_save_IFS=$IFS; IFS='-'
# Line 2267 | Line 2837 | case $host_os in *\ *) host_os=`echo "$host_os" | sed
2837  
2838  
2839   # set program name
2840 < PROGNAME="oopse"
2840 > PROGNAME="openmd"
2841  
2842  
2843  
2844  
2845   OBJEXT=".$OBJEXT"
2846  
2847 < OOPSE=oopse
2847 > OPENMD=openmd
2848  
2849   if test "x${prefix}" = "xNONE"
2850   then
2851 <  OOPSE_HOME=${ac_default_prefix}/oopse
2851 >  OPENMD_HOME=${ac_default_prefix}/openmd
2852   else
2853 <  OOPSE_HOME=${prefix}/oopse
2853 >  OPENMD_HOME=${prefix}/openmd
2854   fi
2855 < # Check whether --enable-oopse-home was given.
2856 < if test "${enable_oopse_home+set}" = set; then
2857 <  enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
2855 > # Check whether --enable-openmd-home was given.
2856 > if test "${enable_openmd_home+set}" = set; then :
2857 >  enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2858   fi
2859  
2860  
# Line 2293 | Line 2863 | debug=0
2863  
2864   debug=0
2865   # Check whether --enable-debug was given.
2866 < if test "${enable_debug+set}" = set; then
2866 > if test "${enable_debug+set}" = set; then :
2867    enableval=$enable_debug; debug=1
2868   fi
2869  
2870   if test "${DEBUG}"; then
2871  
2872 < cat >>confdefs.h <<\_ACEOF
2303 < #define debug 1
2304 < _ACEOF
2872 > $as_echo "#define debug 1" >>confdefs.h
2873  
2874    msg="$msg, debug mode"
2875   fi
2876  
2877  
2878   # Check whether --enable-single was given.
2879 < if test "${enable_single+set}" = set; then
2879 > if test "${enable_single+set}" = set; then :
2880    enableval=$enable_single; ok=$enableval
2881   else
2882    ok=no
2883   fi
2884  
2885   # Check whether --enable-float was given.
2886 < if test "${enable_float+set}" = set; then
2886 > if test "${enable_float+set}" = set; then :
2887    enableval=$enable_float; ok=$enableval
2888   fi
2889  
2890   if test "$ok" = "yes"; then
2891  
2892 < cat >>confdefs.h <<\_ACEOF
2325 < #define SINGLE_PRECISION 1
2326 < _ACEOF
2892 > $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
2893  
2894          USE_SINGLE_PRECISION=yes
2895  
2896   fi
2897  
2898 < if test x"$CC" != x; then
2899 <   for ac_prog in $CC
2900 < do
2901 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
2902 < set dummy $ac_prog; ac_word=$2
2903 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2898 > ac_ext=cpp
2899 > ac_cpp='$CXXCPP $CPPFLAGS'
2900 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2901 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2902 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2903 > if test -z "$CXX"; then
2904 >  if test -n "$CCC"; then
2905 >    CXX=$CCC
2906 >  else
2907 >    if test -n "$ac_tool_prefix"; then
2908 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2909 >  do
2910 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2911 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2912 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2913   $as_echo_n "checking for $ac_word... " >&6; }
2914 < if test "${ac_cv_prog_ac_cc_set+set}" = set; then
2914 > if ${ac_cv_prog_CXX+:} false; then :
2915    $as_echo_n "(cached) " >&6
2916   else
2917 <  if test -n "$ac_cc_set"; then
2918 <  ac_cv_prog_ac_cc_set="$ac_cc_set" # Let the user override the test.
2917 >  if test -n "$CXX"; then
2918 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2919   else
2920   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2921   for as_dir in $PATH
2922   do
2923    IFS=$as_save_IFS
2924    test -z "$as_dir" && as_dir=.
2925 <  for ac_exec_ext in '' $ac_executable_extensions; do
2925 >    for ac_exec_ext in '' $ac_executable_extensions; do
2926    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2927 <    ac_cv_prog_ac_cc_set="$ac_prog"
2928 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2927 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2928 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2929      break 2
2930    fi
2931   done
2932 < done
2932 >  done
2933   IFS=$as_save_IFS
2934  
2935   fi
2936   fi
2937 < ac_cc_set=$ac_cv_prog_ac_cc_set
2938 < if test -n "$ac_cc_set"; then
2939 <  { $as_echo "$as_me:$LINENO: result: $ac_cc_set" >&5
2940 < $as_echo "$ac_cc_set" >&6; }
2937 > CXX=$ac_cv_prog_CXX
2938 > if test -n "$CXX"; then
2939 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
2940 > $as_echo "$CXX" >&6; }
2941   else
2942 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2942 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2943   $as_echo "no" >&6; }
2944   fi
2945  
2946  
2947 <  test -n "$ac_cc_set" && break
2948 < done
2374 < test -n "$ac_cc_set" || ac_cc_set="no"
2375 <
2376 <   if test $ac_cc_set != no; then
2377 <
2378 <     # Extract the first word of "$ac_cc_set", so it can be a program name with args.
2379 < set dummy $ac_cc_set; ac_word=$2
2380 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2381 < $as_echo_n "checking for $ac_word... " >&6; }
2382 < if test "${ac_cv_path_ac_cc_path+set}" = set; then
2383 <  $as_echo_n "(cached) " >&6
2384 < else
2385 <  case $ac_cc_path in
2386 <  [\\/]* | ?:[\\/]*)
2387 <  ac_cv_path_ac_cc_path="$ac_cc_path" # Let the user override the test with a path.
2388 <  ;;
2389 <  *)
2390 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2391 < for as_dir in $PATH
2392 < do
2393 <  IFS=$as_save_IFS
2394 <  test -z "$as_dir" && as_dir=.
2395 <  for ac_exec_ext in '' $ac_executable_extensions; do
2396 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2397 <    ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
2398 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2399 <    break 2
2400 <  fi
2401 < done
2402 < done
2403 < IFS=$as_save_IFS
2404 <
2405 <  test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
2406 <  ;;
2407 < esac
2947 >    test -n "$CXX" && break
2948 >  done
2949   fi
2950 < ac_cc_path=$ac_cv_path_ac_cc_path
2951 < if test -n "$ac_cc_path"; then
2952 <  { $as_echo "$as_me:$LINENO: result: $ac_cc_path" >&5
2412 < $as_echo "$ac_cc_path" >&6; }
2413 < else
2414 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2415 < $as_echo "no" >&6; }
2416 < fi
2417 <
2418 <
2419 < else
2420 <
2421 <     { { $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; }; }
2424 < fi
2425 <
2426 <
2427 <   if test $ac_cc_path != no; then
2428 <
2429 <     { $as_echo "$as_me:$LINENO: Will attempt to use $CC as C compiler" >&5
2430 < $as_echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
2431 < else
2432 <
2433 <     { { $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; }; }
2436 < fi
2437 <
2438 < fi
2439 <
2440 < if test x"$CXX" != x; then
2441 <   for ac_prog in $CXX
2950 > if test -z "$CXX"; then
2951 >  ac_ct_CXX=$CXX
2952 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2953   do
2954    # Extract the first word of "$ac_prog", so it can be a program name with args.
2955   set dummy $ac_prog; ac_word=$2
2956 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2956 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2957   $as_echo_n "checking for $ac_word... " >&6; }
2958 < if test "${ac_cv_prog_ac_cxx_set+set}" = set; then
2958 > if ${ac_cv_prog_ac_ct_CXX+:} false; then :
2959    $as_echo_n "(cached) " >&6
2960   else
2961 <  if test -n "$ac_cxx_set"; then
2962 <  ac_cv_prog_ac_cxx_set="$ac_cxx_set" # Let the user override the test.
2961 >  if test -n "$ac_ct_CXX"; then
2962 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2963   else
2964   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2965   for as_dir in $PATH
2966   do
2967    IFS=$as_save_IFS
2968    test -z "$as_dir" && as_dir=.
2969 <  for ac_exec_ext in '' $ac_executable_extensions; do
2969 >    for ac_exec_ext in '' $ac_executable_extensions; do
2970    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2971 <    ac_cv_prog_ac_cxx_set="$ac_prog"
2972 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2971 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
2972 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2973      break 2
2974    fi
2975   done
2976 < done
2976 >  done
2977   IFS=$as_save_IFS
2978  
2979   fi
2980   fi
2981 < ac_cxx_set=$ac_cv_prog_ac_cxx_set
2982 < if test -n "$ac_cxx_set"; then
2983 <  { $as_echo "$as_me:$LINENO: result: $ac_cxx_set" >&5
2984 < $as_echo "$ac_cxx_set" >&6; }
2981 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2982 > if test -n "$ac_ct_CXX"; then
2983 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
2984 > $as_echo "$ac_ct_CXX" >&6; }
2985   else
2986 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2986 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2987   $as_echo "no" >&6; }
2988   fi
2989  
2990  
2991 <  test -n "$ac_cxx_set" && break
2991 >  test -n "$ac_ct_CXX" && break
2992   done
2482 – test -n "$ac_cxx_set" || ac_cxx_set="no"
2993  
2994 <   if test $ac_cxx_set != no; then
2994 >  if test "x$ac_ct_CXX" = x; then
2995 >    CXX="g++"
2996 >  else
2997 >    case $cross_compiling:$ac_tool_warned in
2998 > yes:)
2999 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3000 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3001 > ac_tool_warned=yes ;;
3002 > esac
3003 >    CXX=$ac_ct_CXX
3004 >  fi
3005 > fi
3006  
2486 –     # Extract the first word of "$ac_cxx_set", so it can be a program name with args.
2487 – set dummy $ac_cxx_set; ac_word=$2
2488 – { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2489 – $as_echo_n "checking for $ac_word... " >&6; }
2490 – if test "${ac_cv_path_ac_cxx_path+set}" = set; then
2491 –  $as_echo_n "(cached) " >&6
2492 – else
2493 –  case $ac_cxx_path in
2494 –  [\\/]* | ?:[\\/]*)
2495 –  ac_cv_path_ac_cxx_path="$ac_cxx_path" # Let the user override the test with a path.
2496 –  ;;
2497 –  *)
2498 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2499 – for as_dir in $PATH
2500 – do
2501 –  IFS=$as_save_IFS
2502 –  test -z "$as_dir" && as_dir=.
2503 –  for ac_exec_ext in '' $ac_executable_extensions; do
2504 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2505 –    ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
2506 –    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2507 –    break 2
3007    fi
3008 + fi
3009 + # Provide some information about the compiler.
3010 + $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3011 + set X $ac_compile
3012 + ac_compiler=$2
3013 + for ac_option in --version -v -V -qversion; do
3014 +  { { ac_try="$ac_compiler $ac_option >&5"
3015 + case "(($ac_try" in
3016 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3017 +  *) ac_try_echo=$ac_try;;
3018 + esac
3019 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3020 + $as_echo "$ac_try_echo"; } >&5
3021 +  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3022 +  ac_status=$?
3023 +  if test -s conftest.err; then
3024 +    sed '10a\
3025 + ... rest of stderr output deleted ...
3026 +         10q' conftest.err >conftest.er1
3027 +    cat conftest.er1 >&5
3028 +  fi
3029 +  rm -f conftest.er1 conftest.err
3030 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3031 +  test $ac_status = 0; }
3032   done
2510 – done
2511 – IFS=$as_save_IFS
3033  
3034 <  test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
3035 <  ;;
2515 < esac
2516 < fi
2517 < ac_cxx_path=$ac_cv_path_ac_cxx_path
2518 < if test -n "$ac_cxx_path"; then
2519 <  { $as_echo "$as_me:$LINENO: result: $ac_cxx_path" >&5
2520 < $as_echo "$ac_cxx_path" >&6; }
2521 < else
2522 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2523 < $as_echo "no" >&6; }
2524 < fi
3034 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3035 > /* end confdefs.h.  */
3036  
3037 + int
3038 + main ()
3039 + {
3040  
3041 < else
3041 >  ;
3042 >  return 0;
3043 > }
3044 > _ACEOF
3045 > ac_clean_files_save=$ac_clean_files
3046 > ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3047 > # Try to create an executable without -o first, disregard a.out.
3048 > # It will help us diagnose broken compilers, and finding out an intuition
3049 > # of exeext.
3050 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3051 > $as_echo_n "checking whether the C++ compiler works... " >&6; }
3052 > ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3053  
3054 <     { { $as_echo "$as_me:$LINENO: error: Specified C++ compiler $CXX doesn't seem to exist!" >&5
3055 < $as_echo "$as_me: error: Specified C++ compiler $CXX doesn't seem to exist!" >&2;}
2531 <   { (exit 1); exit 1; }; }
2532 < fi
3054 > # The possible output files:
3055 > ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3056  
3057 + ac_rmfiles=
3058 + for ac_file in $ac_files
3059 + do
3060 +  case $ac_file in
3061 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3062 +    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3063 +  esac
3064 + done
3065 + rm -f $ac_rmfiles
3066  
3067 <   if test $ac_cxx_path != no; then
3068 <
3069 <     { $as_echo "$as_me:$LINENO: Will attempt to use $CXX as C++ compiler" >&5
3070 < $as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3071 < else
3067 > if { { ac_try="$ac_link_default"
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:${as_lineno-$LINENO}: $ac_try_echo\""
3073 > $as_echo "$ac_try_echo"; } >&5
3074 >  (eval "$ac_link_default") 2>&5
3075 >  ac_status=$?
3076 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3077 >  test $ac_status = 0; }; then :
3078 >  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3079 > # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3080 > # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3081 > # so that the user can short-circuit this test for compilers unknown to
3082 > # Autoconf.
3083 > for ac_file in $ac_files ''
3084 > do
3085 >  test -f "$ac_file" || continue
3086 >  case $ac_file in
3087 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3088 >        ;;
3089 >    [ab].out )
3090 >        # We found the default executable, but exeext='' is most
3091 >        # certainly right.
3092 >        break;;
3093 >    *.* )
3094 >        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3095 >        then :; else
3096 >           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3097 >        fi
3098 >        # We set ac_cv_exeext here because the later test for it is not
3099 >        # safe: cross compilers may not add the suffix if given an `-o'
3100 >        # argument, so we may need to know it at that point already.
3101 >        # Even if this section looks crufty: it has the advantage of
3102 >        # actually working.
3103 >        break;;
3104 >    * )
3105 >        break;;
3106 >  esac
3107 > done
3108 > test "$ac_cv_exeext" = no && ac_cv_exeext=
3109  
3110 <     { { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified C++ compiler $CXX" >&5
3111 < $as_echo "$as_me: error: Can't find path to user-specified C++ compiler $CXX" >&2;}
2543 <   { (exit 1); exit 1; }; }
3110 > else
3111 >  ac_file=''
3112   fi
3113 + if test -z "$ac_file"; then :
3114 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3115 + $as_echo "no" >&6; }
3116 + $as_echo "$as_me: failed program was:" >&5
3117 + sed 's/^/| /' conftest.$ac_ext >&5
3118  
3119 + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3120 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3121 + as_fn_error 77 "C++ compiler cannot create executables
3122 + See \`config.log' for more details" "$LINENO" 5; }
3123 + else
3124 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3125 + $as_echo "yes" >&6; }
3126   fi
3127 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3128 + $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3129 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3130 + $as_echo "$ac_file" >&6; }
3131 + ac_exeext=$ac_cv_exeext
3132  
3133 < if test x"$FC" != x; then
3134 <   for ac_prog in $FC
3135 < do
3136 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3137 < set dummy $ac_prog; ac_word=$2
3138 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3139 < $as_echo_n "checking for $ac_word... " >&6; }
3140 < if test "${ac_cv_prog_ac_fc_set+set}" = set; then
3141 <  $as_echo_n "(cached) " >&6
3142 < else
3143 <  if test -n "$ac_fc_set"; then
3144 <  ac_cv_prog_ac_fc_set="$ac_fc_set" # Let the user override the test.
3145 < else
3146 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3147 < for as_dir in $PATH
3148 < do
3149 <  IFS=$as_save_IFS
3150 <  test -z "$as_dir" && as_dir=.
3151 <  for ac_exec_ext in '' $ac_executable_extensions; do
3152 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3153 <    ac_cv_prog_ac_fc_set="$ac_prog"
3154 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3155 <    break 2
3156 <  fi
3133 > rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3134 > ac_clean_files=$ac_clean_files_save
3135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3136 > $as_echo_n "checking for suffix of executables... " >&6; }
3137 > if { { ac_try="$ac_link"
3138 > case "(($ac_try" in
3139 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3140 >  *) ac_try_echo=$ac_try;;
3141 > esac
3142 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3143 > $as_echo "$ac_try_echo"; } >&5
3144 >  (eval "$ac_link") 2>&5
3145 >  ac_status=$?
3146 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3147 >  test $ac_status = 0; }; then :
3148 >  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3149 > # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3150 > # work properly (i.e., refer to `conftest.exe'), while it won't with
3151 > # `rm'.
3152 > for ac_file in conftest.exe conftest conftest.*; do
3153 >  test -f "$ac_file" || continue
3154 >  case $ac_file in
3155 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3156 >    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3157 >          break;;
3158 >    * ) break;;
3159 >  esac
3160   done
2573 – done
2574 – IFS=$as_save_IFS
2575 –
2576 – fi
2577 – fi
2578 – ac_fc_set=$ac_cv_prog_ac_fc_set
2579 – if test -n "$ac_fc_set"; then
2580 –  { $as_echo "$as_me:$LINENO: result: $ac_fc_set" >&5
2581 – $as_echo "$ac_fc_set" >&6; }
3161   else
3162 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3163 < $as_echo "no" >&6; }
3162 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3163 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3164 > as_fn_error $? "cannot compute suffix of executables: cannot compile and link
3165 > See \`config.log' for more details" "$LINENO" 5; }
3166   fi
3167 + rm -f conftest conftest$ac_cv_exeext
3168 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3169 + $as_echo "$ac_cv_exeext" >&6; }
3170  
3171 + rm -f conftest.$ac_ext
3172 + EXEEXT=$ac_cv_exeext
3173 + ac_exeext=$EXEEXT
3174 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3175 + /* end confdefs.h.  */
3176 + #include <stdio.h>
3177 + int
3178 + main ()
3179 + {
3180 + FILE *f = fopen ("conftest.out", "w");
3181 + return ferror (f) || fclose (f) != 0;
3182  
3183 <  test -n "$ac_fc_set" && break
3184 < done
3185 < test -n "$ac_fc_set" || ac_fc_set="no"
3183 >  ;
3184 >  return 0;
3185 > }
3186 > _ACEOF
3187 > ac_clean_files="$ac_clean_files conftest.out"
3188 > # Check that the compiler produces executables we can run.  If not, either
3189 > # the compiler is broken, or we cross compile.
3190 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3191 > $as_echo_n "checking whether we are cross compiling... " >&6; }
3192 > if test "$cross_compiling" != yes; then
3193 >  { { ac_try="$ac_link"
3194 > case "(($ac_try" in
3195 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3196 >  *) ac_try_echo=$ac_try;;
3197 > esac
3198 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3199 > $as_echo "$ac_try_echo"; } >&5
3200 >  (eval "$ac_link") 2>&5
3201 >  ac_status=$?
3202 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3203 >  test $ac_status = 0; }
3204 >  if { ac_try='./conftest$ac_cv_exeext'
3205 >  { { case "(($ac_try" in
3206 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3207 >  *) ac_try_echo=$ac_try;;
3208 > esac
3209 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3210 > $as_echo "$ac_try_echo"; } >&5
3211 >  (eval "$ac_try") 2>&5
3212 >  ac_status=$?
3213 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3214 >  test $ac_status = 0; }; }; then
3215 >    cross_compiling=no
3216 >  else
3217 >    if test "$cross_compiling" = maybe; then
3218 >        cross_compiling=yes
3219 >    else
3220 >        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3221 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3222 > as_fn_error $? "cannot run C++ compiled programs.
3223 > If you meant to cross compile, use \`--host'.
3224 > See \`config.log' for more details" "$LINENO" 5; }
3225 >    fi
3226 >  fi
3227 > fi
3228 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3229 > $as_echo "$cross_compiling" >&6; }
3230  
3231 <   if test $ac_fc_set != no; then
3232 <
3233 <     # Extract the first word of "$ac_fc_set", so it can be a program name with args.
3234 < set dummy $ac_fc_set; ac_word=$2
3235 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2597 < $as_echo_n "checking for $ac_word... " >&6; }
2598 < if test "${ac_cv_path_ac_fc_path+set}" = set; then
3231 > rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3232 > ac_clean_files=$ac_clean_files_save
3233 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3234 > $as_echo_n "checking for suffix of object files... " >&6; }
3235 > if ${ac_cv_objext+:} false; then :
3236    $as_echo_n "(cached) " >&6
3237   else
3238 <  case $ac_fc_path in
3239 <  [\\/]* | ?:[\\/]*)
2603 <  ac_cv_path_ac_fc_path="$ac_fc_path" # Let the user override the test with a path.
2604 <  ;;
2605 <  *)
2606 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2607 < for as_dir in $PATH
2608 < do
2609 <  IFS=$as_save_IFS
2610 <  test -z "$as_dir" && as_dir=.
2611 <  for ac_exec_ext in '' $ac_executable_extensions; do
2612 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2613 <    ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
2614 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2615 <    break 2
2616 <  fi
2617 < done
2618 < done
2619 < IFS=$as_save_IFS
3238 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3239 > /* end confdefs.h.  */
3240  
3241 <  test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
3242 <  ;;
3241 > int
3242 > main ()
3243 > {
3244 >
3245 >  ;
3246 >  return 0;
3247 > }
3248 > _ACEOF
3249 > rm -f conftest.o conftest.obj
3250 > if { { ac_try="$ac_compile"
3251 > case "(($ac_try" in
3252 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3253 >  *) ac_try_echo=$ac_try;;
3254   esac
3255 < fi
3256 < ac_fc_path=$ac_cv_path_ac_fc_path
3257 < if test -n "$ac_fc_path"; then
3258 <  { $as_echo "$as_me:$LINENO: result: $ac_fc_path" >&5
3259 < $as_echo "$ac_fc_path" >&6; }
3255 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3256 > $as_echo "$ac_try_echo"; } >&5
3257 >  (eval "$ac_compile") 2>&5
3258 >  ac_status=$?
3259 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3260 >  test $ac_status = 0; }; then :
3261 >  for ac_file in conftest.o conftest.obj conftest.*; do
3262 >  test -f "$ac_file" || continue;
3263 >  case $ac_file in
3264 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3265 >    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3266 >       break;;
3267 >  esac
3268 > done
3269   else
3270 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3271 < $as_echo "no" >&6; }
3270 >  $as_echo "$as_me: failed program was:" >&5
3271 > sed 's/^/| /' conftest.$ac_ext >&5
3272 >
3273 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3274 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3275 > as_fn_error $? "cannot compute suffix of object files: cannot compile
3276 > See \`config.log' for more details" "$LINENO" 5; }
3277   fi
3278 + rm -f conftest.$ac_cv_objext conftest.$ac_ext
3279 + fi
3280 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3281 + $as_echo "$ac_cv_objext" >&6; }
3282 + OBJEXT=$ac_cv_objext
3283 + ac_objext=$OBJEXT
3284 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3285 + $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3286 + if ${ac_cv_cxx_compiler_gnu+:} false; then :
3287 +  $as_echo_n "(cached) " >&6
3288 + else
3289 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3290 + /* end confdefs.h.  */
3291  
3292 + int
3293 + main ()
3294 + {
3295 + #ifndef __GNUC__
3296 +       choke me
3297 + #endif
3298  
3299 +  ;
3300 +  return 0;
3301 + }
3302 + _ACEOF
3303 + if ac_fn_cxx_try_compile "$LINENO"; then :
3304 +  ac_compiler_gnu=yes
3305   else
3306 <
2637 <     { { $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; }; }
3306 >  ac_compiler_gnu=no
3307   fi
3308 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3309 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3310  
3311 <
3312 <   if test $ac_fc_path != no; then
3313 <
3314 <     { $as_echo "$as_me:$LINENO: Will attempt to use $FC as Fortran compiler" >&5
3315 < $as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3311 > fi
3312 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3313 > $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3314 > if test $ac_compiler_gnu = yes; then
3315 >  GXX=yes
3316   else
3317 <
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; }; }
3317 >  GXX=
3318   fi
3319 + ac_test_CXXFLAGS=${CXXFLAGS+set}
3320 + ac_save_CXXFLAGS=$CXXFLAGS
3321 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3322 + $as_echo_n "checking whether $CXX accepts -g... " >&6; }
3323 + if ${ac_cv_prog_cxx_g+:} false; then :
3324 +  $as_echo_n "(cached) " >&6
3325 + else
3326 +  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3327 +   ac_cxx_werror_flag=yes
3328 +   ac_cv_prog_cxx_g=no
3329 +   CXXFLAGS="-g"
3330 +   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3331 + /* end confdefs.h.  */
3332  
3333 < fi
3333 > int
3334 > main ()
3335 > {
3336  
3337 <
3338 <
3339 <
3340 < # Check whether --with-mpi was given.
3341 < if test "${with_mpi+set}" = set; then
3342 <  withval=$with_mpi;
3337 >  ;
3338 >  return 0;
3339 > }
3340 > _ACEOF
3341 > if ac_fn_cxx_try_compile "$LINENO"; then :
3342 >  ac_cv_prog_cxx_g=yes
3343   else
3344 <  with_mpi="auto"
3345 < fi
3344 >  CXXFLAGS=""
3345 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3346 > /* end confdefs.h.  */
3347  
3348 < if test "x$with_mpi" != "xno"; then
3348 > int
3349 > main ()
3350 > {
3351  
3352 +  ;
3353 +  return 0;
3354 + }
3355 + _ACEOF
3356 + if ac_fn_cxx_try_compile "$LINENO"; then :
3357  
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
3358   else
3359 <  if test -n "$acx_mpi_mpicc"; then
3360 <  ac_cv_prog_acx_mpi_mpicc="$acx_mpi_mpicc" # Let the user override the test.
3361 < else
3362 < 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
3359 >  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3360 >         CXXFLAGS="-g"
3361 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3362 > /* end confdefs.h.  */
3363  
3364 + int
3365 + main ()
3366 + {
3367 +
3368 +  ;
3369 +  return 0;
3370 + }
3371 + _ACEOF
3372 + if ac_fn_cxx_try_compile "$LINENO"; then :
3373 +  ac_cv_prog_cxx_g=yes
3374   fi
3375 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3376   fi
3377 < 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; }
3377 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3378   fi
3379 <
3380 <
3381 <  test -n "$acx_mpi_mpicc" && break
3382 < done
3383 < test -n "$acx_mpi_mpicc" || acx_mpi_mpicc="no"
3384 <
3385 < if test $acx_mpi_mpicc != no; then
3386 <
3387 <  # Extract the first word of "$acx_mpi_mpicc", so it can be a program name with args.
3388 < set dummy $acx_mpi_mpicc; ac_word=$2
3389 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3390 < $as_echo_n "checking for $ac_word... " >&6; }
3391 < if test "${ac_cv_path_acx_mpi_mpicc_path+set}" = set; then
2719 <  $as_echo_n "(cached) " >&6
3379 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3380 >   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3381 > fi
3382 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3383 > $as_echo "$ac_cv_prog_cxx_g" >&6; }
3384 > if test "$ac_test_CXXFLAGS" = set; then
3385 >  CXXFLAGS=$ac_save_CXXFLAGS
3386 > elif test $ac_cv_prog_cxx_g = yes; then
3387 >  if test "$GXX" = yes; then
3388 >    CXXFLAGS="-g -O2"
3389 >  else
3390 >    CXXFLAGS="-g"
3391 >  fi
3392   else
3393 <  case $acx_mpi_mpicc_path in
3394 <  [\\/]* | ?:[\\/]*)
3395 <  ac_cv_path_acx_mpi_mpicc_path="$acx_mpi_mpicc_path" # Let the user override the test with a path.
3396 <  ;;
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
3393 >  if test "$GXX" = yes; then
3394 >    CXXFLAGS="-O2"
3395 >  else
3396 >    CXXFLAGS=
3397    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
3398   fi
3399 < acx_mpi_mpicc_path=$ac_cv_path_acx_mpi_mpicc_path
3400 < if test -n "$acx_mpi_mpicc_path"; then
3401 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicc_path" >&5
3402 < $as_echo "$acx_mpi_mpicc_path" >&6; }
3403 < else
2750 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2751 < $as_echo "no" >&6; }
2752 < fi
3399 > ac_ext=c
3400 > ac_cpp='$CPP $CPPFLAGS'
3401 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3402 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3403 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3404  
3405 <
3406 < fi
3407 <
3408 < for ac_prog in $FC openmpif90 mpif90
3409 < do
3410 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3411 < set dummy $ac_prog; ac_word=$2
3412 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3405 > ac_ext=c
3406 > ac_cpp='$CPP $CPPFLAGS'
3407 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3408 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3409 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3410 > if test -n "$ac_tool_prefix"; then
3411 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3412 >  do
3413 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3414 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3415 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3416   $as_echo_n "checking for $ac_word... " >&6; }
3417 < if test "${ac_cv_prog_acx_mpi_mpif90+set}" = set; then
3417 > if ${ac_cv_prog_CC+:} false; then :
3418    $as_echo_n "(cached) " >&6
3419   else
3420 <  if test -n "$acx_mpi_mpif90"; then
3421 <  ac_cv_prog_acx_mpi_mpif90="$acx_mpi_mpif90" # Let the user override the test.
3420 >  if test -n "$CC"; then
3421 >  ac_cv_prog_CC="$CC" # Let the user override the test.
3422   else
3423   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3424   for as_dir in $PATH
3425   do
3426    IFS=$as_save_IFS
3427    test -z "$as_dir" && as_dir=.
3428 <  for ac_exec_ext in '' $ac_executable_extensions; do
3428 >    for ac_exec_ext in '' $ac_executable_extensions; do
3429    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3430 <    ac_cv_prog_acx_mpi_mpif90="$ac_prog"
3431 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3430 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3431 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3432      break 2
3433    fi
3434   done
3435 < done
3435 >  done
3436   IFS=$as_save_IFS
3437  
3438   fi
3439   fi
3440 < acx_mpi_mpif90=$ac_cv_prog_acx_mpi_mpif90
3441 < if test -n "$acx_mpi_mpif90"; then
3442 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpif90" >&5
3443 < $as_echo "$acx_mpi_mpif90" >&6; }
3440 > CC=$ac_cv_prog_CC
3441 > if test -n "$CC"; then
3442 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3443 > $as_echo "$CC" >&6; }
3444   else
3445 <  { $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
3445 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3446   $as_echo "no" >&6; }
3447   fi
3448  
3449  
3450 +    test -n "$CC" && break
3451 +  done
3452   fi
3453 <
3454 < for ac_prog in $CXX openmpicxx openmpiCC openmpic++ mpicxx mpiCC mpic++
3453 > if test -z "$CC"; then
3454 >  ac_ct_CC=$CC
3455 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3456   do
3457    # Extract the first word of "$ac_prog", so it can be a program name with args.
3458   set dummy $ac_prog; ac_word=$2
3459 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3459 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3460   $as_echo_n "checking for $ac_word... " >&6; }
3461 < if test "${ac_cv_prog_acx_mpi_mpicxx+set}" = set; then
3461 > if ${ac_cv_prog_ac_ct_CC+:} false; then :
3462    $as_echo_n "(cached) " >&6
3463   else
3464 <  if test -n "$acx_mpi_mpicxx"; then
3465 <  ac_cv_prog_acx_mpi_mpicxx="$acx_mpi_mpicxx" # Let the user override the test.
3464 >  if test -n "$ac_ct_CC"; then
3465 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3466   else
3467   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3468   for as_dir in $PATH
3469   do
3470    IFS=$as_save_IFS
3471    test -z "$as_dir" && as_dir=.
3472 <  for ac_exec_ext in '' $ac_executable_extensions; do
3472 >    for ac_exec_ext in '' $ac_executable_extensions; do
3473    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3474 <    ac_cv_prog_acx_mpi_mpicxx="$ac_prog"
3475 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3474 >    ac_cv_prog_ac_ct_CC="$ac_prog"
3475 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3476      break 2
3477    fi
3478   done
3479 < done
3479 >  done
3480   IFS=$as_save_IFS
3481  
3482   fi
3483   fi
3484 < acx_mpi_mpicxx=$ac_cv_prog_acx_mpi_mpicxx
3485 < if test -n "$acx_mpi_mpicxx"; then
3486 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicxx" >&5
3487 < $as_echo "$acx_mpi_mpicxx" >&6; }
3484 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
3485 > if test -n "$ac_ct_CC"; then
3486 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3487 > $as_echo "$ac_ct_CC" >&6; }
3488   else
3489 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3489 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3490   $as_echo "no" >&6; }
3491   fi
3492  
3493  
3494 <  test -n "$acx_mpi_mpicxx" && break
3494 >  test -n "$ac_ct_CC" && break
3495   done
2886 – test -n "$acx_mpi_mpicxx" || acx_mpi_mpicxx="no"
3496  
3497 < if test $acx_mpi_mpicxx != no; then
3498 <
3499 <  # Extract the first word of "$acx_mpi_mpicxx", so it can be a program name with args.
3500 < set dummy $acx_mpi_mpicxx; ac_word=$2
3501 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3502 < $as_echo_n "checking for $ac_word... " >&6; }
3503 < if test "${ac_cv_path_acx_mpi_mpicxx_path+set}" = set; then
3504 <  $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 <  ;;
3497 >  if test "x$ac_ct_CC" = x; then
3498 >    CC=""
3499 >  else
3500 >    case $cross_compiling:$ac_tool_warned in
3501 > yes:)
3502 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3503 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3504 > ac_tool_warned=yes ;;
3505   esac
3506 +    CC=$ac_ct_CC
3507 +  fi
3508   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
3509  
3510  
3511 < fi
3511 > test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3512 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3513 > as_fn_error $? "no acceptable C compiler found in \$PATH
3514 > See \`config.log' for more details" "$LINENO" 5; }
3515  
3516 < if test $acx_mpi_mpicc = no; then
3516 > # Provide some information about the compiler.
3517 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
3518 > set X $ac_compile
3519 > ac_compiler=$2
3520 > for ac_option in --version -v -V -qversion; do
3521 >  { { ac_try="$ac_compiler $ac_option >&5"
3522 > case "(($ac_try" in
3523 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3524 >  *) ac_try_echo=$ac_try;;
3525 > esac
3526 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3527 > $as_echo "$ac_try_echo"; } >&5
3528 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3529 >  ac_status=$?
3530 >  if test -s conftest.err; then
3531 >    sed '10a\
3532 > ... rest of stderr output deleted ...
3533 >         10q' conftest.err >conftest.er1
3534 >    cat conftest.er1 >&5
3535 >  fi
3536 >  rm -f conftest.er1 conftest.err
3537 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3538 >  test $ac_status = 0; }
3539 > done
3540  
3541 <  if test $acx_mpi_mpicxx = no; then
3541 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
3542 > $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3543 > if ${ac_cv_c_compiler_gnu+:} false; then :
3544 >  $as_echo_n "(cached) " >&6
3545 > else
3546 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3547 > /* end confdefs.h.  */
3548  
3549 <    acx_mpi_compiler=no
3549 > int
3550 > main ()
3551 > {
3552 > #ifndef __GNUC__
3553 >       choke me
3554 > #endif
3555  
3556 +  ;
3557 +  return 0;
3558 + }
3559 + _ACEOF
3560 + if ac_fn_c_try_compile "$LINENO"; then :
3561 +  ac_compiler_gnu=yes
3562   else
3563 <
2941 <    acx_mpi_compiler=$acx_mpi_mpicxx
2942 <    acx_mpi_compiler_path=$acx_mpi_mpicxx_path
3563 >  ac_compiler_gnu=no
3564   fi
3565 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3566 + ac_cv_c_compiler_gnu=$ac_compiler_gnu
3567  
3568 <
3568 > fi
3569 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
3570 > $as_echo "$ac_cv_c_compiler_gnu" >&6; }
3571 > if test $ac_compiler_gnu = yes; then
3572 >  GCC=yes
3573   else
3574 <
3575 <  if test $acx_mpi_mpicxx = no; then
3576 <
3577 <    acx_mpi_compiler=$acx_mpi_mpicc
3578 <    acx_mpi_compiler_path=$acx_mpi_mpicc_path
3579 <
3574 >  GCC=
3575 > fi
3576 > ac_test_CFLAGS=${CFLAGS+set}
3577 > ac_save_CFLAGS=$CFLAGS
3578 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
3579 > $as_echo_n "checking whether $CC accepts -g... " >&6; }
3580 > if ${ac_cv_prog_cc_g+:} false; then :
3581 >  $as_echo_n "(cached) " >&6
3582   else
3583 <
3584 <    { $as_echo "$as_me:$LINENO: checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx" >&5
3585 < $as_echo_n "checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx... " >&6; }
3586 <    ac_ext=cpp
3587 < ac_cpp='$CXXCPP $CPPFLAGS'
2959 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2960 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2961 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2962 <
2963 <    cat >conftest.$ac_ext <<_ACEOF
2964 < /* confdefs.h.  */
2965 < _ACEOF
2966 < cat confdefs.h >>conftest.$ac_ext
2967 < cat >>conftest.$ac_ext <<_ACEOF
3583 >  ac_save_c_werror_flag=$ac_c_werror_flag
3584 >   ac_c_werror_flag=yes
3585 >   ac_cv_prog_cc_g=no
3586 >   CFLAGS="-g"
3587 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3588   /* end confdefs.h.  */
3589  
2970 – #include <mpi.h>
2971 –
3590   int
3591   main ()
3592   {
3593  
2976 – MPI_Finalize();
2977 –
3594    ;
3595    return 0;
3596   }
3597   _ACEOF
3598 <    if { (ac_try="$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5"
3599 < case "(($ac_try" in
3600 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3601 <  *) ac_try_echo=$ac_try;;
3602 < esac
3603 < 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
3598 > if ac_fn_c_try_compile "$LINENO"; then :
3599 >  ac_cv_prog_cc_g=yes
3600 > else
3601 >  CFLAGS=""
3602 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3603 > /* end confdefs.h.  */
3604  
3605 <      acx_mpi_compiler=$acx_mpi_mpicxx
3606 <      acx_mpi_compiler_path=$acx_mpi_mpicxx_path
3605 > int
3606 > main ()
3607 > {
3608  
3609 +  ;
3610 +  return 0;
3611 + }
3612 + _ACEOF
3613 + if ac_fn_c_try_compile "$LINENO"; then :
3614 +
3615   else
3616 +  ac_c_werror_flag=$ac_save_c_werror_flag
3617 +         CFLAGS="-g"
3618 +         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3619 + /* end confdefs.h.  */
3620  
3621 <      acx_mpi_compiler=$acx_mpi_mpicc
3622 <      acx_mpi_compiler_path=$acx_mpi_mpicc_path
3621 > int
3622 > main ()
3623 > {
3624 >
3625 >  ;
3626 >  return 0;
3627 > }
3628 > _ACEOF
3629 > if ac_fn_c_try_compile "$LINENO"; then :
3630 >  ac_cv_prog_cc_g=yes
3631   fi
3632 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3633 + fi
3634 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3635 + fi
3636 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3637 +   ac_c_werror_flag=$ac_save_c_werror_flag
3638 + fi
3639 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
3640 + $as_echo "$ac_cv_prog_cc_g" >&6; }
3641 + if test "$ac_test_CFLAGS" = set; then
3642 +  CFLAGS=$ac_save_CFLAGS
3643 + elif test $ac_cv_prog_cc_g = yes; then
3644 +  if test "$GCC" = yes; then
3645 +    CFLAGS="-g -O2"
3646 +  else
3647 +    CFLAGS="-g"
3648 +  fi
3649 + else
3650 +  if test "$GCC" = yes; then
3651 +    CFLAGS="-O2"
3652 +  else
3653 +    CFLAGS=
3654 +  fi
3655 + fi
3656 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
3657 + $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
3658 + if ${ac_cv_prog_cc_c89+:} false; then :
3659 +  $as_echo_n "(cached) " >&6
3660 + else
3661 +  ac_cv_prog_cc_c89=no
3662 + ac_save_CC=$CC
3663 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3664 + /* end confdefs.h.  */
3665 + #include <stdarg.h>
3666 + #include <stdio.h>
3667 + #include <sys/types.h>
3668 + #include <sys/stat.h>
3669 + /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3670 + struct buf { int x; };
3671 + FILE * (*rcsopen) (struct buf *, struct stat *, int);
3672 + static char *e (p, i)
3673 +     char **p;
3674 +     int i;
3675 + {
3676 +  return p[i];
3677 + }
3678 + static char *f (char * (*g) (char **, int), char **p, ...)
3679 + {
3680 +  char *s;
3681 +  va_list v;
3682 +  va_start (v,p);
3683 +  s = g (p, va_arg (v,int));
3684 +  va_end (v);
3685 +  return s;
3686 + }
3687  
3688 <    ac_ext=c
3689 < ac_cpp='$CPP $CPPFLAGS'
3690 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3691 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3692 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3688 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3689 >   function prototypes and stuff, but not '\xHH' hex character constants.
3690 >   These don't provoke an error unfortunately, instead are silently treated
3691 >   as 'x'.  The following induces an error, until -std is added to get
3692 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3693 >   array size at least.  It's necessary to write '\x00'==0 to get something
3694 >   that's true only with -std.  */
3695 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3696  
3697 <    { $as_echo "$as_me:$LINENO: result: $acx_mpi_compiler" >&5
3698 < $as_echo "$acx_mpi_compiler" >&6; }
3697 > /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
3698 >   inside strings and character constants.  */
3699 > #define FOO(x) 'x'
3700 > int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
3701 >
3702 > int test (int i, double x);
3703 > struct s1 {int (*f) (int a);};
3704 > struct s2 {int (*f) (double a);};
3705 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3706 > int argc;
3707 > char **argv;
3708 > int
3709 > main ()
3710 > {
3711 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3712 >  ;
3713 >  return 0;
3714 > }
3715 > _ACEOF
3716 > for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
3717 >        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3718 > do
3719 >  CC="$ac_save_CC $ac_arg"
3720 >  if ac_fn_c_try_compile "$LINENO"; then :
3721 >  ac_cv_prog_cc_c89=$ac_arg
3722   fi
3723 + rm -f core conftest.err conftest.$ac_objext
3724 +  test "x$ac_cv_prog_cc_c89" != "xno" && break
3725 + done
3726 + rm -f conftest.$ac_ext
3727 + CC=$ac_save_CC
3728  
3729   fi
3730 + # AC_CACHE_VAL
3731 + case "x$ac_cv_prog_cc_c89" in
3732 +  x)
3733 +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
3734 + $as_echo "none needed" >&6; } ;;
3735 +  xno)
3736 +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
3737 + $as_echo "unsupported" >&6; } ;;
3738 +  *)
3739 +    CC="$CC $ac_cv_prog_cc_c89"
3740 +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
3741 + $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
3742 + esac
3743 + if test "x$ac_cv_prog_cc_c89" != xno; then :
3744  
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; }
3745   fi
3746 < rm -f conftest*
3050 < ac_ext=$ac_save_ext
3746 >
3747   ac_ext=c
3748   ac_cpp='$CPP $CPPFLAGS'
3749   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3750   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3751   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3752  
3057 – if test $acx_mpi_compiler = no || test $acx_mpi_f90_compiler = no; then
3753  
3754 < acx_cv_mpi_implementation=no
3755 < else
3756 <  { $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
3754 > save_CXX=$CXX
3755 > save_CC=$CC
3756 > save_LIBS=$LIBS
3757  
3758 <  acx_cv_mpi_implementation=lammpi
3758 > ac_ext=cpp
3759 > ac_cpp='$CXXCPP $CPPFLAGS'
3760 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3761 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3762 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3763  
3084 – else
3764  
3765 <  if { (ac_try="grep -q showme $acx_mpi_compiler_path"
3766 < case "(($ac_try" in
3767 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3768 <  *) 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 <
3765 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
3766 > $as_echo_n "checking for dlopen in -lc... " >&6; }
3767 > if ${ac_cv_lib_c_dlopen+:} false; then :
3768 >  $as_echo_n "(cached) " >&6
3769   else
3770 +  ac_check_lib_save_LIBS=$LIBS
3771 + LIBS="-lc  $LIBS"
3772 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3773 + /* end confdefs.h.  */
3774  
3775 <    if { (ac_try="grep -q MPICH $acx_mpi_compiler_path"
3776 < case "(($ac_try" in
3777 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3778 <  *) ac_try_echo=$ac_try;;
3779 < esac
3780 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3781 < $as_echo "$ac_try_echo") >&5
3782 <  (eval "grep -q MPICH $acx_mpi_compiler_path") 2>conftest.er1
3783 <  ac_status=$?
3784 <  grep -v '^ *+' conftest.er1 >conftest.err
3785 <  rm -f conftest.er1
3786 <  cat conftest.err >&5
3787 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3788 <  (exit $ac_status); }; then
3789 <
3790 <      acx_cv_mpi_implementation=mpich
3791 <
3792 < else
3793 <  acx_cv_mpi_implementation=$with_mpi
3124 < fi
3125 <
3775 > /* Override any GCC internal prototype to avoid an error.
3776 >   Use char because int might match the return type of a GCC
3777 >   builtin and then its argument prototype would still apply.  */
3778 > #ifdef __cplusplus
3779 > extern "C"
3780 > #endif
3781 > char dlopen ();
3782 > int
3783 > main ()
3784 > {
3785 > return dlopen ();
3786 >  ;
3787 >  return 0;
3788 > }
3789 > _ACEOF
3790 > if ac_fn_cxx_try_link "$LINENO"; then :
3791 >  ac_cv_lib_c_dlopen=yes
3792 > else
3793 >  ac_cv_lib_c_dlopen=no
3794   fi
3795 <
3795 > rm -f core conftest.err conftest.$ac_objext \
3796 >    conftest$ac_exeext conftest.$ac_ext
3797 > LIBS=$ac_check_lib_save_LIBS
3798   fi
3799 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
3800 + $as_echo "$ac_cv_lib_c_dlopen" >&6; }
3801 + if test "x$ac_cv_lib_c_dlopen" = xyes; then :
3802 +  LIBDL=""
3803 + else
3804 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
3805 + $as_echo_n "checking for dlopen in -ldl... " >&6; }
3806 + if ${ac_cv_lib_dl_dlopen+:} false; then :
3807 +  $as_echo_n "(cached) " >&6
3808 + else
3809 +  ac_check_lib_save_LIBS=$LIBS
3810 + LIBS="-ldl  $LIBS"
3811 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3812 + /* end confdefs.h.  */
3813  
3814 + /* Override any GCC internal prototype to avoid an error.
3815 +   Use char because int might match the return type of a GCC
3816 +   builtin and then its argument prototype would still apply.  */
3817 + #ifdef __cplusplus
3818 + extern "C"
3819 + #endif
3820 + char dlopen ();
3821 + int
3822 + main ()
3823 + {
3824 + return dlopen ();
3825 +  ;
3826 +  return 0;
3827 + }
3828 + _ACEOF
3829 + if ac_fn_cxx_try_link "$LINENO"; then :
3830 +  ac_cv_lib_dl_dlopen=yes
3831 + else
3832 +  ac_cv_lib_dl_dlopen=no
3833   fi
3834 < { $as_echo "$as_me:$LINENO: result: $acx_cv_mpi_implementation" >&5
3835 < $as_echo "$acx_cv_mpi_implementation" >&6; }
3834 > rm -f core conftest.err conftest.$ac_objext \
3835 >    conftest$ac_exeext conftest.$ac_ext
3836 > LIBS=$ac_check_lib_save_LIBS
3837 > fi
3838 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
3839 > $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
3840 > if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
3841 >  LIBDL="-ldl"
3842 > fi
3843  
3844   fi
3135 – case $acx_cv_mpi_implementation in
3136 – (lammpi)
3845  
3138 – cat >>confdefs.h <<\_ACEOF
3139 – #define MPI_IS_LAMMPI 1
3140 – _ACEOF
3846  
3142 –  ;;
3143 – (openmpi)
3847  
3145 – cat >>confdefs.h <<\_ACEOF
3146 – #define MPI_IS_OPENMPI 1
3147 – _ACEOF
3848  
3149 –  ;;
3150 – (mpich)
3849  
3152 – cat >>confdefs.h <<\_ACEOF
3153 – #define MPI_IS_MPICH 1
3154 – _ACEOF
3850  
3156 –  ;;
3157 – esac
3158 – if test $acx_cv_mpi_implementation = no; then
3851  
3852 < acx_mpi_cflags=""
3853 < acx_mpi_libs=""
3854 < USE_MPI="no"
3855 <        { $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3856 < $as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3852 >        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3853 > do
3854 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
3855 > set dummy $ac_prog; ac_word=$2
3856 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3857 > $as_echo_n "checking for $ac_word... " >&6; }
3858 > if ${ac_cv_prog_MPICXX+:} false; then :
3859 >  $as_echo_n "(cached) " >&6
3860   else
3861 +  if test -n "$MPICXX"; then
3862 +  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3863 + else
3864 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3865 + for as_dir in $PATH
3866 + do
3867 +  IFS=$as_save_IFS
3868 +  test -z "$as_dir" && as_dir=.
3869 +    for ac_exec_ext in '' $ac_executable_extensions; do
3870 +  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3871 +    ac_cv_prog_MPICXX="$ac_prog"
3872 +    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3873 +    break 2
3874 +  fi
3875 + done
3876 +  done
3877 + IFS=$as_save_IFS
3878  
3879 <
3880 < { $as_echo "$as_me:$LINENO: checking how to compile MPI-C code" >&5
3881 < $as_echo_n "checking how to compile MPI-C code... " >&6; }
3882 < if test "${acx_mpi_cflags+set}" = set; then
3883 <  $as_echo_n "(cached) " >&6
3879 > fi
3880 > fi
3881 > MPICXX=$ac_cv_prog_MPICXX
3882 > if test -n "$MPICXX"; then
3883 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3884 > $as_echo "$MPICXX" >&6; }
3885   else
3886 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3887 + $as_echo "no" >&6; }
3888 + fi
3889  
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
3890  
3891 <    ;;
3892 < esac
3891 >  test -n "$MPICXX" && break
3892 > done
3893 > test -n "$MPICXX" || MPICXX="$CXX"
3894  
3895 +        ax_mpi_save_CXX="$CXX"
3896 +        CXX="$MPICXX"
3897 +
3898 +
3899 +
3900 + if test x = x"$MPILIBS"; then
3901 +        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3902 + if test "x$ac_cv_func_MPI_Init" = xyes; then :
3903 +  MPILIBS=" "
3904   fi
3246 – { $as_echo "$as_me:$LINENO: result: $acx_mpi_cflags" >&5
3247 – $as_echo "$acx_mpi_cflags" >&6; }
3905  
3906 + fi
3907  
3908 < { $as_echo "$as_me:$LINENO: checking how to link MPI-C code" >&5
3909 < $as_echo_n "checking how to link MPI-C code... " >&6; }
3910 < if test "${acx_mpi_libs+set}" = set; then
3908 > if test x = x"$MPILIBS"; then
3909 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3910 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3911 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
3912    $as_echo_n "(cached) " >&6
3913   else
3914 +  ac_check_lib_save_LIBS=$LIBS
3915 + LIBS="-lmpi  $LIBS"
3916 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3917 + /* end confdefs.h.  */
3918  
3919 < case $acx_cv_mpi_implementation in
3920 <  (lammpi)
3921 <    lfo="--showme:compile --showme:link"
3922 <    ;;
3923 <  (openmpi)
3924 <    lfo="--showme:link"
3925 <    ;;
3926 <  (mpich)
3927 <    case "$acx_mpi_compiler_path" in
3928 <      (*mpiCC)
3929 <        sc_cv_cn="-CC="
3930 <        ;;
3931 <      (*mpicxx)
3932 <        sc_cv_cn="-cxx="
3933 <        ;;
3934 <      (*mpicc)
3935 <        sc_cv_cn="-cc="
3936 <        ;;
3937 <      (*)
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 <
3919 > /* Override any GCC internal prototype to avoid an error.
3920 >   Use char because int might match the return type of a GCC
3921 >   builtin and then its argument prototype would still apply.  */
3922 > #ifdef __cplusplus
3923 > extern "C"
3924 > #endif
3925 > char MPI_Init ();
3926 > int
3927 > main ()
3928 > {
3929 > return MPI_Init ();
3930 >  ;
3931 >  return 0;
3932 > }
3933 > _ACEOF
3934 > if ac_fn_cxx_try_link "$LINENO"; then :
3935 >  ac_cv_lib_mpi_MPI_Init=yes
3936 > else
3937 >  ac_cv_lib_mpi_MPI_Init=no
3938   fi
3939 < { $as_echo "$as_me:$LINENO: result: $acx_mpi_libs" >&5
3940 < $as_echo "$acx_mpi_libs" >&6; }
3939 > rm -f core conftest.err conftest.$ac_objext \
3940 >    conftest$ac_exeext conftest.$ac_ext
3941 > LIBS=$ac_check_lib_save_LIBS
3942 > fi
3943 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3944 > $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3945 > if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
3946 >  MPILIBS="-lmpi"
3947 > fi
3948  
3949 < if test $acx_mpi_mpif90_path != no; then
3950 <
3951 <
3952 <  { $as_echo "$as_me:$LINENO: checking how to link MPI-Fortran code" >&5
3953 < $as_echo_n "checking how to link MPI-Fortran code... " >&6; }
3305 < if test "${acx_mpi90_libs+set}" = set; then
3949 > fi
3950 > if test x = x"$MPILIBS"; then
3951 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3952 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3953 > if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
3954    $as_echo_n "(cached) " >&6
3955   else
3956 +  ac_check_lib_save_LIBS=$LIBS
3957 + LIBS="-lmpich  $LIBS"
3958 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3959 + /* end confdefs.h.  */
3960  
3961 <    $as_echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_mpif90_path $lfo || echo \" no\"\`\"" >&5
3962 <    mpi_pre_libs="`$acx_mpi_mpif90_path $lfo 2>conftest.er1 || echo " no"`"
3963 <    grep -v '^ *+' conftest.er1 >conftest.err
3964 <    rm -f conftest.er1
3965 <    cat conftest.err >&5
3966 <    $as_echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3967 <    case "$mpi_pre_libs" in
3968 <      (*no)
3969 <        acx_mpi90_libs=no
3970 <        ;;
3971 <      (*)
3972 <        acx_mpi90_libs="$mpi_pre_libs"
3973 <        ;;
3974 <    esac
3975 <
3961 > /* Override any GCC internal prototype to avoid an error.
3962 >   Use char because int might match the return type of a GCC
3963 >   builtin and then its argument prototype would still apply.  */
3964 > #ifdef __cplusplus
3965 > extern "C"
3966 > #endif
3967 > char MPI_Init ();
3968 > int
3969 > main ()
3970 > {
3971 > return MPI_Init ();
3972 >  ;
3973 >  return 0;
3974 > }
3975 > _ACEOF
3976 > if ac_fn_cxx_try_link "$LINENO"; then :
3977 >  ac_cv_lib_mpich_MPI_Init=yes
3978 > else
3979 >  ac_cv_lib_mpich_MPI_Init=no
3980   fi
3981 < { $as_echo "$as_me:$LINENO: result: $acx_mpi90_libs" >&5
3982 < $as_echo "$acx_mpi90_libs" >&6; }
3981 > rm -f core conftest.err conftest.$ac_objext \
3982 >    conftest$ac_exeext conftest.$ac_ext
3983 > LIBS=$ac_check_lib_save_LIBS
3984 > fi
3985 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
3986 > $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
3987 > if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
3988 >  MPILIBS="-lmpich"
3989 > fi
3990  
3328 –
3991   fi
3992  
3993 < if test "$acx_mpi_cflags" = no -o "$acx_mpi_libs" = no; then
3993 > if test x != x"$MPILIBS"; then
3994 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
3995 > $as_echo_n "checking for mpi.h... " >&6; }
3996 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3997 > /* end confdefs.h.  */
3998 > #include <mpi.h>
3999 > int
4000 > main ()
4001 > {
4002  
4003 < acx_mpi_cflags=""
4004 < acx_mpi_libs=""
4005 < USE_MPI="no"
4006 <        { $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
4007 < $as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
4003 >  ;
4004 >  return 0;
4005 > }
4006 > _ACEOF
4007 > if ac_fn_cxx_try_compile "$LINENO"; then :
4008 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4009 > $as_echo "yes" >&6; }
4010   else
4011 +  MPILIBS=""
4012 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4013 + $as_echo "no" >&6; }
4014 + fi
4015 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4016 + fi
4017  
4018 < MPI_CPPFLAGS=$acx_mpi_cflags
4018 > CXX="$ax_mpi_save_CXX"
4019  
3342 – MPI_LIBS=$acx_mpi_libs
4020  
3344 – if test "$acx_mpi90_libs" != no; then
3345 –  MPI90_LIBS=$acx_mpi90_libs
4021  
4022 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4023 + if test x = x"$MPILIBS"; then
4024 +        USE_MPI="no"
4025 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4026 + $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4027 +        :
4028 + else
4029 +        USE_MPI="yes"
4030 +        :
4031   fi
4032  
3349 – USE_MPI="yes"
3350 – fi
4033  
4034 + if test $USE_MPI != no; then :
4035  
4036 < fi
4036 > ac_ext=c
4037 > ac_cpp='$CPP $CPPFLAGS'
4038 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4039 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4040 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4041  
4042  
3356 – fi
4043  
4044  
4045  
4046 < # Checks for programs.
4047 < ac_ext=cpp
4048 < ac_cpp='$CXXCPP $CPPFLAGS'
4049 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4050 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4051 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3366 < if test -z "$CXX"; then
3367 <  if test -n "$CCC"; then
3368 <    CXX=$CCC
3369 <  else
3370 <    if test -n "$ac_tool_prefix"; then
3371 <  for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3372 <  do
3373 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3374 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3375 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4046 >
4047 >        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4048 > do
4049 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
4050 > set dummy $ac_prog; ac_word=$2
4051 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4052   $as_echo_n "checking for $ac_word... " >&6; }
4053 < if test "${ac_cv_prog_CXX+set}" = set; then
4053 > if ${ac_cv_prog_MPICC+:} false; then :
4054    $as_echo_n "(cached) " >&6
4055   else
4056 <  if test -n "$CXX"; then
4057 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
4056 >  if test -n "$MPICC"; then
4057 >  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4058   else
4059   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4060   for as_dir in $PATH
4061   do
4062    IFS=$as_save_IFS
4063    test -z "$as_dir" && as_dir=.
4064 <  for ac_exec_ext in '' $ac_executable_extensions; do
4064 >    for ac_exec_ext in '' $ac_executable_extensions; do
4065    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4066 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
4067 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4066 >    ac_cv_prog_MPICC="$ac_prog"
4067 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4068      break 2
4069    fi
4070   done
4071 < done
4071 >  done
4072   IFS=$as_save_IFS
4073  
4074   fi
4075   fi
4076 < CXX=$ac_cv_prog_CXX
4077 < if test -n "$CXX"; then
4078 <  { $as_echo "$as_me:$LINENO: result: $CXX" >&5
4079 < $as_echo "$CXX" >&6; }
4076 > MPICC=$ac_cv_prog_MPICC
4077 > if test -n "$MPICC"; then
4078 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4079 > $as_echo "$MPICC" >&6; }
4080   else
4081 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4081 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4082   $as_echo "no" >&6; }
4083   fi
4084  
4085  
4086 <    test -n "$CXX" && break
3411 <  done
3412 < fi
3413 < if test -z "$CXX"; then
3414 <  ac_ct_CXX=$CXX
3415 <  for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3416 < do
3417 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3418 < set dummy $ac_prog; ac_word=$2
3419 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3420 < $as_echo_n "checking for $ac_word... " >&6; }
3421 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3422 <  $as_echo_n "(cached) " >&6
3423 < else
3424 <  if test -n "$ac_ct_CXX"; then
3425 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3426 < else
3427 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3428 < for as_dir in $PATH
3429 < do
3430 <  IFS=$as_save_IFS
3431 <  test -z "$as_dir" && as_dir=.
3432 <  for ac_exec_ext in '' $ac_executable_extensions; do
3433 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3434 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
3435 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3436 <    break 2
3437 <  fi
4086 >  test -n "$MPICC" && break
4087   done
4088 < done
3440 < IFS=$as_save_IFS
4088 > test -n "$MPICC" || MPICC="$CC"
4089  
4090 +        ax_mpi_save_CC="$CC"
4091 +        CC="$MPICC"
4092 +
4093 +
4094 +
4095 + if test x = x"$MPILIBS"; then
4096 +        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4097 + if test "x$ac_cv_func_MPI_Init" = xyes; then :
4098 +  MPILIBS=" "
4099   fi
4100 +
4101   fi
4102 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
4103 < if test -n "$ac_ct_CXX"; then
4104 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
4105 < $as_echo "$ac_ct_CXX" >&6; }
4102 >
4103 > if test x = x"$MPILIBS"; then
4104 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4105 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4106 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
4107 >  $as_echo_n "(cached) " >&6
4108   else
4109 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4110 < $as_echo "no" >&6; }
4109 >  ac_check_lib_save_LIBS=$LIBS
4110 > LIBS="-lmpi  $LIBS"
4111 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4112 > /* end confdefs.h.  */
4113 >
4114 > /* Override any GCC internal prototype to avoid an error.
4115 >   Use char because int might match the return type of a GCC
4116 >   builtin and then its argument prototype would still apply.  */
4117 > #ifdef __cplusplus
4118 > extern "C"
4119 > #endif
4120 > char MPI_Init ();
4121 > int
4122 > main ()
4123 > {
4124 > return MPI_Init ();
4125 >  ;
4126 >  return 0;
4127 > }
4128 > _ACEOF
4129 > if ac_fn_c_try_link "$LINENO"; then :
4130 >  ac_cv_lib_mpi_MPI_Init=yes
4131 > else
4132 >  ac_cv_lib_mpi_MPI_Init=no
4133   fi
4134 + rm -f core conftest.err conftest.$ac_objext \
4135 +    conftest$ac_exeext conftest.$ac_ext
4136 + LIBS=$ac_check_lib_save_LIBS
4137 + fi
4138 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4139 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4140 + if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
4141 +  MPILIBS="-lmpi"
4142 + fi
4143  
4144 + fi
4145 + if test x = x"$MPILIBS"; then
4146 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4147 + $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4148 + if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
4149 +  $as_echo_n "(cached) " >&6
4150 + else
4151 +  ac_check_lib_save_LIBS=$LIBS
4152 + LIBS="-lmpich  $LIBS"
4153 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4154 + /* end confdefs.h.  */
4155  
4156 <  test -n "$ac_ct_CXX" && break
4157 < done
4158 <
4159 <  if test "x$ac_ct_CXX" = x; then
4160 <    CXX="g++"
4161 <  else
4162 <    case $cross_compiling:$ac_tool_warned in
4163 < yes:)
4164 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4165 < whose name does not start with the host triplet.  If you think this
4166 < configuration is useful to you, please write to autoconf@gnu.org." >&5
4167 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
4168 < whose name does not start with the host triplet.  If you think this
4169 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4170 < ac_tool_warned=yes ;;
4171 < esac
4172 <    CXX=$ac_ct_CXX
4173 <  fi
4156 > /* Override any GCC internal prototype to avoid an error.
4157 >   Use char because int might match the return type of a GCC
4158 >   builtin and then its argument prototype would still apply.  */
4159 > #ifdef __cplusplus
4160 > extern "C"
4161 > #endif
4162 > char MPI_Init ();
4163 > int
4164 > main ()
4165 > {
4166 > return MPI_Init ();
4167 >  ;
4168 >  return 0;
4169 > }
4170 > _ACEOF
4171 > if ac_fn_c_try_link "$LINENO"; then :
4172 >  ac_cv_lib_mpich_MPI_Init=yes
4173 > else
4174 >  ac_cv_lib_mpich_MPI_Init=no
4175   fi
4176 + rm -f core conftest.err conftest.$ac_objext \
4177 +    conftest$ac_exeext conftest.$ac_ext
4178 + LIBS=$ac_check_lib_save_LIBS
4179 + fi
4180 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4181 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4182 + if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
4183 +  MPILIBS="-lmpich"
4184 + fi
4185  
3474 –  fi
4186   fi
3476 – # Provide some information about the compiler.
3477 – $as_echo "$as_me:$LINENO: checking for C++ compiler version" >&5
3478 – set X $ac_compile
3479 – ac_compiler=$2
3480 – { (ac_try="$ac_compiler --version >&5"
3481 – case "(($ac_try" in
3482 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3483 –  *) ac_try_echo=$ac_try;;
3484 – esac
3485 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3486 – $as_echo "$ac_try_echo") >&5
3487 –  (eval "$ac_compiler --version >&5") 2>&5
3488 –  ac_status=$?
3489 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3490 –  (exit $ac_status); }
3491 – { (ac_try="$ac_compiler -v >&5"
3492 – case "(($ac_try" in
3493 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3494 –  *) ac_try_echo=$ac_try;;
3495 – esac
3496 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3497 – $as_echo "$ac_try_echo") >&5
3498 –  (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); }
4187  
4188 < cat >conftest.$ac_ext <<_ACEOF
4189 < /* confdefs.h.  */
4190 < _ACEOF
4191 < cat confdefs.h >>conftest.$ac_ext
3518 < cat >>conftest.$ac_ext <<_ACEOF
4188 > if test x != x"$MPILIBS"; then
4189 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4190 > $as_echo_n "checking for mpi.h... " >&6; }
4191 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4192   /* end confdefs.h.  */
4193 <
4193 > #include <mpi.h>
4194   int
4195   main ()
4196   {
# Line 3526 | Line 4199 | _ACEOF
4199    return 0;
4200   }
4201   _ACEOF
4202 < ac_clean_files_save=$ac_clean_files
4203 < ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
4204 < # Try to create an executable without -o first, disregard a.out.
4205 < # It will help us diagnose broken compilers, and finding out an intuition
4206 < # of exeext.
4207 < { $as_echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
4208 < $as_echo_n "checking for C++ compiler default output file name... " >&6; }
4209 < ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
4202 > if ac_fn_c_try_compile "$LINENO"; then :
4203 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4204 > $as_echo "yes" >&6; }
4205 > else
4206 >  MPILIBS=""
4207 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4208 > $as_echo "no" >&6; }
4209 > fi
4210 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4211 > fi
4212  
4213 < # The possible output files:
3539 < ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
4213 > CC="$ax_mpi_save_CC"
4214  
3541 – ac_rmfiles=
3542 – for ac_file in $ac_files
3543 – do
3544 –  case $ac_file in
3545 –    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3546 –    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3547 –  esac
3548 – done
3549 – rm -f $ac_rmfiles
4215  
3551 – if { (ac_try="$ac_link_default"
3552 – case "(($ac_try" in
3553 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3554 –  *) ac_try_echo=$ac_try;;
3555 – esac
3556 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3557 – $as_echo "$ac_try_echo") >&5
3558 –  (eval "$ac_link_default") 2>&5
3559 –  ac_status=$?
3560 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3561 –  (exit $ac_status); }; then
3562 –  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3563 – # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3564 – # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3565 – # so that the user can short-circuit this test for compilers unknown to
3566 – # Autoconf.
3567 – for ac_file in $ac_files ''
3568 – do
3569 –  test -f "$ac_file" || continue
3570 –  case $ac_file in
3571 –    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3572 –        ;;
3573 –    [ab].out )
3574 –        # We found the default executable, but exeext='' is most
3575 –        # certainly right.
3576 –        break;;
3577 –    *.* )
3578 –        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3579 –        then :; else
3580 –           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3581 –        fi
3582 –        # We set ac_cv_exeext here because the later test for it is not
3583 –        # safe: cross compilers may not add the suffix if given an `-o'
3584 –        # argument, so we may need to know it at that point already.
3585 –        # Even if this section looks crufty: it has the advantage of
3586 –        # actually working.
3587 –        break;;
3588 –    * )
3589 –        break;;
3590 –  esac
3591 – done
3592 – test "$ac_cv_exeext" = no && ac_cv_exeext=
4216  
4217 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4218 + if test x = x"$MPILIBS"; then
4219 +        USE_MPI="no"
4220 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4221 + $as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4222 +        :
4223   else
4224 <  ac_file=''
4224 >        USE_MPI="yes"
4225 >        :
4226   fi
4227  
3598 – { $as_echo "$as_me:$LINENO: result: $ac_file" >&5
3599 – $as_echo "$ac_file" >&6; }
3600 – if test -z "$ac_file"; then
3601 –  $as_echo "$as_me: failed program was:" >&5
3602 – sed 's/^/| /' conftest.$ac_ext >&5
4228  
3604 – { { $as_echo "$as_me:$LINENO: error: C++ compiler cannot create executables
3605 – See \`config.log' for more details." >&5
3606 – $as_echo "$as_me: error: C++ compiler cannot create executables
3607 – See \`config.log' for more details." >&2;}
3608 –   { (exit 77); exit 77; }; }
4229   fi
4230 + if test $USE_MPI != no; then :
4231  
4232 < ac_exeext=$ac_cv_exeext
4232 >        CXX=$MPICXX
4233 >        CC=$MPICC
4234 >        LIBS="$MPILIBS $LIBS"
4235  
4236 < # Check that the compiler produces executables we can run.  If not, either
4237 < # the compiler is broken, or we cross compile.
4238 < { $as_echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
4239 < $as_echo_n "checking whether the C++ compiler works... " >&6; }
4240 < # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
4241 < # If not cross compiling, check that we can run a simple program.
4242 < if test "$cross_compiling" != yes; then
4243 <  if { ac_try='./$ac_file'
4244 <  { (case "(($ac_try" in
4245 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4246 <  *) ac_try_echo=$ac_try;;
4247 < esac
4248 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4249 < $as_echo "$ac_try_echo") >&5
4250 <  (eval "$ac_try") 2>&5
4251 <  ac_status=$?
4252 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4253 <  (exit $ac_status); }; }; then
4254 <    cross_compiling=no
4255 <  else
4256 <    if test "$cross_compiling" = maybe; then
4257 <        cross_compiling=yes
4258 <    else
4259 <        { { $as_echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
4260 < If you meant to cross compile, use \`--host'.
4261 < See \`config.log' for more details." >&5
4262 < $as_echo "$as_me: error: cannot run C++ compiled programs.
4263 < If you meant to cross compile, use \`--host'.
4264 < See \`config.log' for more details." >&2;}
4265 <   { (exit 1); exit 1; }; }
4266 <    fi
4267 <  fi
4268 < fi
4269 < { $as_echo "$as_me:$LINENO: result: yes" >&5
4270 < $as_echo "yes" >&6; }
4271 <
4272 < rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
4273 < ac_clean_files=$ac_clean_files_save
4274 < # Check that the compiler produces executables we can run.  If not, either
4275 < # the compiler is broken, or we cross compile.
4276 < { $as_echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
4277 < $as_echo_n "checking whether we are cross compiling... " >&6; }
4278 < { $as_echo "$as_me:$LINENO: result: $cross_compiling" >&5
4279 < $as_echo "$cross_compiling" >&6; }
4280 <
4281 < { $as_echo "$as_me:$LINENO: checking for suffix of executables" >&5
4282 < $as_echo_n "checking for suffix of executables... " >&6; }
4283 < if { (ac_try="$ac_link"
4284 < case "(($ac_try" in
4285 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4286 <  *) ac_try_echo=$ac_try;;
4287 < esac
4288 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4289 < $as_echo "$ac_try_echo") >&5
4290 <  (eval "$ac_link") 2>&5
4291 <  ac_status=$?
4292 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4293 <  (exit $ac_status); }; then
4294 <  # If both `conftest.exe' and `conftest' are `present' (well, observable)
4295 < # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
4296 < # work properly (i.e., refer to `conftest.exe'), while it won't with
4297 < # `rm'.
4298 < for ac_file in conftest.exe conftest conftest.*; do
4299 <  test -f "$ac_file" || continue
4300 <  case $ac_file in
4301 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
4302 <    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
4303 <          break;;
4304 <    * ) break;;
4305 <  esac
4306 < done
4307 < else
4308 <  { { $as_echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
4309 < See \`config.log' for more details." >&5
4310 < $as_echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
4311 < See \`config.log' for more details." >&2;}
4312 <   { (exit 1); exit 1; }; }
4313 < fi
4314 <
4315 < rm -f conftest$ac_cv_exeext
4316 < { $as_echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
4317 < $as_echo "$ac_cv_exeext" >&6; }
4318 <
4319 < rm -f conftest.$ac_ext
4320 < EXEEXT=$ac_cv_exeext
4321 < ac_exeext=$EXEEXT
4322 < { $as_echo "$as_me:$LINENO: checking for suffix of object files" >&5
4323 < $as_echo_n "checking for suffix of object files... " >&6; }
4324 < if test "${ac_cv_objext+set}" = set; then
4325 <  $as_echo_n "(cached) " >&6
4326 < else
4327 <  cat >conftest.$ac_ext <<_ACEOF
4328 < /* confdefs.h.  */
4329 < _ACEOF
4330 < cat confdefs.h >>conftest.$ac_ext
4331 < cat >>conftest.$ac_ext <<_ACEOF
4332 < /* end confdefs.h.  */
4333 <
4334 < int
4335 < main ()
4336 < {
4337 <
4338 <  ;
4339 <  return 0;
4340 < }
4341 < _ACEOF
4342 < rm -f conftest.o conftest.obj
4343 < if { (ac_try="$ac_compile"
4344 < case "(($ac_try" in
4345 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4346 <  *) ac_try_echo=$ac_try;;
4347 < esac
4348 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4349 < $as_echo "$ac_try_echo") >&5
4350 <  (eval "$ac_compile") 2>&5
4351 <  ac_status=$?
4352 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4353 <  (exit $ac_status); }; then
4354 <  for ac_file in conftest.o conftest.obj conftest.*; do
4355 <  test -f "$ac_file" || continue;
4356 <  case $ac_file in
4357 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
4358 <    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
4359 <       break;;
4360 <  esac
4361 < done
4362 < else
4363 <  $as_echo "$as_me: failed program was:" >&5
4364 < sed 's/^/| /' conftest.$ac_ext >&5
4365 <
4366 < { { $as_echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
4367 < See \`config.log' for more details." >&5
4368 < $as_echo "$as_me: error: cannot compute suffix of object files: cannot compile
4369 < See \`config.log' for more details." >&2;}
4370 <   { (exit 1); exit 1; }; }
4371 < fi
4372 <
4373 < rm -f conftest.$ac_cv_objext conftest.$ac_ext
4374 < fi
4375 < { $as_echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
4376 < $as_echo "$ac_cv_objext" >&6; }
4377 < OBJEXT=$ac_cv_objext
4378 < ac_objext=$OBJEXT
4379 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4380 < $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
4381 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4382 <  $as_echo_n "(cached) " >&6
4383 < else
4384 <  cat >conftest.$ac_ext <<_ACEOF
4385 < /* confdefs.h.  */
4386 < _ACEOF
4387 < cat confdefs.h >>conftest.$ac_ext
4388 < cat >>conftest.$ac_ext <<_ACEOF
4389 < /* end confdefs.h.  */
4390 <
4391 < int
4392 < main ()
4393 < {
4394 < #ifndef __GNUC__
4395 <       choke me
4396 < #endif
4397 <
4398 <  ;
4399 <  return 0;
4400 < }
4401 < _ACEOF
4402 < rm -f conftest.$ac_objext
4403 < if { (ac_try="$ac_compile"
4404 < case "(($ac_try" in
4405 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4406 <  *) ac_try_echo=$ac_try;;
4407 < esac
4408 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4409 < $as_echo "$ac_try_echo") >&5
4410 <  (eval "$ac_compile") 2>conftest.er1
4411 <  ac_status=$?
4412 <  grep -v '^ *+' conftest.er1 >conftest.err
4413 <  rm -f conftest.er1
4414 <  cat conftest.err >&5
4415 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4416 <  (exit $ac_status); } && {
4417 <         test -z "$ac_cxx_werror_flag" ||
4418 <         test ! -s conftest.err
4419 <       } && test -s conftest.$ac_objext; then
4420 <  ac_compiler_gnu=yes
4421 < else
4422 <  $as_echo "$as_me: failed program was:" >&5
4423 < sed 's/^/| /' conftest.$ac_ext >&5
4424 <
4425 <        ac_compiler_gnu=no
4426 < fi
4427 <
4428 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4429 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4430 <
4431 < fi
4432 < { $as_echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4433 < $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
4434 < if test $ac_compiler_gnu = yes; then
4435 <  GXX=yes
4436 < else
4437 <  GXX=
4438 < fi
4439 < ac_test_CXXFLAGS=${CXXFLAGS+set}
4440 < ac_save_CXXFLAGS=$CXXFLAGS
4441 < { $as_echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4442 < $as_echo_n "checking whether $CXX accepts -g... " >&6; }
4443 < if test "${ac_cv_prog_cxx_g+set}" = set; then
4444 <  $as_echo_n "(cached) " >&6
4445 < else
4446 <  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
4447 <   ac_cxx_werror_flag=yes
4448 <   ac_cv_prog_cxx_g=no
4449 <   CXXFLAGS="-g"
4450 <   cat >conftest.$ac_ext <<_ACEOF
4451 < /* confdefs.h.  */
4452 < _ACEOF
4453 < cat confdefs.h >>conftest.$ac_ext
4454 < cat >>conftest.$ac_ext <<_ACEOF
4455 < /* end confdefs.h.  */
4456 <
4457 < int
4458 < main ()
4459 < {
4460 <
4461 <  ;
4462 <  return 0;
4463 < }
4464 < _ACEOF
4465 < rm -f conftest.$ac_objext
4466 < if { (ac_try="$ac_compile"
4467 < case "(($ac_try" in
4468 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4469 <  *) ac_try_echo=$ac_try;;
4470 < esac
4471 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4472 < $as_echo "$ac_try_echo") >&5
4473 <  (eval "$ac_compile") 2>conftest.er1
4474 <  ac_status=$?
4475 <  grep -v '^ *+' conftest.er1 >conftest.err
4476 <  rm -f conftest.er1
4477 <  cat conftest.err >&5
4478 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4479 <  (exit $ac_status); } && {
4480 <         test -z "$ac_cxx_werror_flag" ||
4481 <         test ! -s conftest.err
4482 <       } && test -s conftest.$ac_objext; then
4483 <  ac_cv_prog_cxx_g=yes
4484 < else
4485 <  $as_echo "$as_me: failed program was:" >&5
4486 < sed 's/^/| /' conftest.$ac_ext >&5
4487 <
4488 <        CXXFLAGS=""
4489 <      cat >conftest.$ac_ext <<_ACEOF
4490 < /* confdefs.h.  */
4491 < _ACEOF
4492 < cat confdefs.h >>conftest.$ac_ext
4493 < cat >>conftest.$ac_ext <<_ACEOF
4494 < /* end confdefs.h.  */
4495 <
4496 < int
4497 < main ()
4498 < {
4499 <
4500 <  ;
4501 <  return 0;
4502 < }
4503 < _ACEOF
4504 < rm -f conftest.$ac_objext
4505 < if { (ac_try="$ac_compile"
4506 < case "(($ac_try" in
4507 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4508 <  *) ac_try_echo=$ac_try;;
4509 < esac
4510 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4511 < $as_echo "$ac_try_echo") >&5
4512 <  (eval "$ac_compile") 2>conftest.er1
4513 <  ac_status=$?
4514 <  grep -v '^ *+' conftest.er1 >conftest.err
4515 <  rm -f conftest.er1
4516 <  cat conftest.err >&5
4517 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4518 <  (exit $ac_status); } && {
4519 <         test -z "$ac_cxx_werror_flag" ||
4520 <         test ! -s conftest.err
4521 <       } && test -s conftest.$ac_objext; then
4522 <  :
4523 < else
4524 <  $as_echo "$as_me: failed program was:" >&5
4525 < sed 's/^/| /' conftest.$ac_ext >&5
4526 <
4527 <        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
4528 <         CXXFLAGS="-g"
4529 <         cat >conftest.$ac_ext <<_ACEOF
4530 < /* confdefs.h.  */
4531 < _ACEOF
4532 < cat confdefs.h >>conftest.$ac_ext
4533 < cat >>conftest.$ac_ext <<_ACEOF
4534 < /* end confdefs.h.  */
4535 <
4536 < int
4537 < main ()
4538 < {
4539 <
4540 <  ;
4541 <  return 0;
4542 < }
4543 < _ACEOF
4544 < rm -f conftest.$ac_objext
4545 < if { (ac_try="$ac_compile"
4546 < case "(($ac_try" in
4547 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4548 <  *) ac_try_echo=$ac_try;;
4549 < esac
4550 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4551 < $as_echo "$ac_try_echo") >&5
4552 <  (eval "$ac_compile") 2>conftest.er1
4553 <  ac_status=$?
4554 <  grep -v '^ *+' conftest.er1 >conftest.err
4555 <  rm -f conftest.er1
4556 <  cat conftest.err >&5
4557 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4558 <  (exit $ac_status); } && {
4559 <         test -z "$ac_cxx_werror_flag" ||
4560 <         test ! -s conftest.err
4561 <       } && test -s conftest.$ac_objext; then
4562 <  ac_cv_prog_cxx_g=yes
4563 < else
4564 <  $as_echo "$as_me: failed program was:" >&5
4565 < sed 's/^/| /' conftest.$ac_ext >&5
4566 <
4567 <
4568 < fi
4569 <
4570 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4571 < fi
4572 <
4573 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4574 < fi
4575 <
4576 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4577 <   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
4578 < fi
4579 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4580 < $as_echo "$ac_cv_prog_cxx_g" >&6; }
4581 < if test "$ac_test_CXXFLAGS" = set; then
4582 <  CXXFLAGS=$ac_save_CXXFLAGS
4583 < elif test $ac_cv_prog_cxx_g = yes; then
4584 <  if test "$GXX" = yes; then
4585 <    CXXFLAGS="-g -O2"
4586 <  else
4587 <    CXXFLAGS="-g"
4588 <  fi
4589 < else
4590 <  if test "$GXX" = yes; then
4591 <    CXXFLAGS="-O2"
4592 <  else
4593 <    CXXFLAGS=
4594 <  fi
4595 < fi
4596 < ac_ext=c
4597 < ac_cpp='$CPP $CPPFLAGS'
4598 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4599 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4600 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4601 <
4602 < ac_ext=c
4603 < ac_cpp='$CPP $CPPFLAGS'
4604 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4605 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4606 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4607 < if test -n "$ac_tool_prefix"; then
4608 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4609 <  do
4610 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4611 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4612 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4613 < $as_echo_n "checking for $ac_word... " >&6; }
4614 < if test "${ac_cv_prog_CC+set}" = set; then
4615 <  $as_echo_n "(cached) " >&6
4616 < else
4617 <  if test -n "$CC"; then
4618 <  ac_cv_prog_CC="$CC" # Let the user override the test.
4619 < else
4620 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4621 < for as_dir in $PATH
4622 < do
4623 <  IFS=$as_save_IFS
4624 <  test -z "$as_dir" && as_dir=.
4625 <  for ac_exec_ext in '' $ac_executable_extensions; do
4626 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4627 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4628 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4629 <    break 2
4630 <  fi
4631 < done
4632 < done
4633 < IFS=$as_save_IFS
4634 <
4635 < fi
4636 < fi
4637 < CC=$ac_cv_prog_CC
4638 < if test -n "$CC"; then
4639 <  { $as_echo "$as_me:$LINENO: result: $CC" >&5
4640 < $as_echo "$CC" >&6; }
4641 < else
4642 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4643 < $as_echo "no" >&6; }
4644 < fi
4645 <
4646 <
4647 <    test -n "$CC" && break
4648 <  done
4649 < fi
4650 < if test -z "$CC"; then
4651 <  ac_ct_CC=$CC
4652 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4653 < do
4654 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4655 < set dummy $ac_prog; ac_word=$2
4656 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4657 < $as_echo_n "checking for $ac_word... " >&6; }
4658 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4659 <  $as_echo_n "(cached) " >&6
4660 < else
4661 <  if test -n "$ac_ct_CC"; then
4662 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4663 < else
4664 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4665 < for as_dir in $PATH
4666 < do
4667 <  IFS=$as_save_IFS
4668 <  test -z "$as_dir" && as_dir=.
4669 <  for ac_exec_ext in '' $ac_executable_extensions; do
4670 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4671 <    ac_cv_prog_ac_ct_CC="$ac_prog"
4672 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4673 <    break 2
4674 <  fi
4675 < done
4676 < done
4677 < IFS=$as_save_IFS
4678 <
4679 < fi
4680 < fi
4681 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
4682 < if test -n "$ac_ct_CC"; then
4683 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4684 < $as_echo "$ac_ct_CC" >&6; }
4685 < else
4686 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4687 < $as_echo "no" >&6; }
4688 < fi
4689 <
4690 <
4691 <  test -n "$ac_ct_CC" && break
4692 < done
4693 <
4694 <  if test "x$ac_ct_CC" = x; then
4695 <    CC=""
4696 <  else
4697 <    case $cross_compiling:$ac_tool_warned in
4698 < yes:)
4699 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4077 < 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;}
4082 < ac_tool_warned=yes ;;
4083 < esac
4084 <    CC=$ac_ct_CC
4085 <  fi
4086 < fi
4087 <
4088 <
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; }; }
4094 <
4095 < # Provide some information about the compiler.
4096 < $as_echo "$as_me:$LINENO: checking for C compiler version" >&5
4097 < set X $ac_compile
4098 < ac_compiler=$2
4099 < { (ac_try="$ac_compiler --version >&5"
4100 < case "(($ac_try" in
4101 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4102 <  *) ac_try_echo=$ac_try;;
4103 < esac
4104 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4105 < $as_echo "$ac_try_echo") >&5
4106 <  (eval "$ac_compiler --version >&5") 2>&5
4107 <  ac_status=$?
4108 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4109 <  (exit $ac_status); }
4110 < { (ac_try="$ac_compiler -v >&5"
4111 < case "(($ac_try" in
4112 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4113 <  *) ac_try_echo=$ac_try;;
4114 < esac
4115 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4116 < $as_echo "$ac_try_echo") >&5
4117 <  (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); }
4132 <
4133 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
4134 < $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
4135 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
4136 <  $as_echo_n "(cached) " >&6
4137 < else
4138 <  cat >conftest.$ac_ext <<_ACEOF
4139 < /* confdefs.h.  */
4140 < _ACEOF
4141 < cat confdefs.h >>conftest.$ac_ext
4142 < cat >>conftest.$ac_ext <<_ACEOF
4143 < /* end confdefs.h.  */
4144 <
4145 < int
4146 < main ()
4147 < {
4148 < #ifndef __GNUC__
4149 <       choke me
4150 < #endif
4151 <
4152 <  ;
4153 <  return 0;
4154 < }
4155 < _ACEOF
4156 < 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
4174 <  ac_compiler_gnu=yes
4175 < else
4176 <  $as_echo "$as_me: failed program was:" >&5
4177 < sed 's/^/| /' conftest.$ac_ext >&5
4178 <
4179 <        ac_compiler_gnu=no
4180 < fi
4181 <
4182 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4183 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
4184 <
4185 < fi
4186 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
4187 < $as_echo "$ac_cv_c_compiler_gnu" >&6; }
4188 < if test $ac_compiler_gnu = yes; then
4189 <  GCC=yes
4190 < else
4191 <  GCC=
4192 < fi
4193 < ac_test_CFLAGS=${CFLAGS+set}
4194 < ac_save_CFLAGS=$CFLAGS
4195 < { $as_echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
4196 < $as_echo_n "checking whether $CC accepts -g... " >&6; }
4197 < if test "${ac_cv_prog_cc_g+set}" = set; then
4198 <  $as_echo_n "(cached) " >&6
4199 < else
4200 <  ac_save_c_werror_flag=$ac_c_werror_flag
4201 <   ac_c_werror_flag=yes
4202 <   ac_cv_prog_cc_g=no
4203 <   CFLAGS="-g"
4204 <   cat >conftest.$ac_ext <<_ACEOF
4205 < /* confdefs.h.  */
4206 < _ACEOF
4207 < cat confdefs.h >>conftest.$ac_ext
4208 < cat >>conftest.$ac_ext <<_ACEOF
4209 < /* end confdefs.h.  */
4210 <
4211 < int
4212 < main ()
4213 < {
4214 <
4215 <  ;
4216 <  return 0;
4217 < }
4218 < _ACEOF
4219 < 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
4237 <  ac_cv_prog_cc_g=yes
4238 < else
4239 <  $as_echo "$as_me: failed program was:" >&5
4240 < 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
4248 < /* end confdefs.h.  */
4249 <
4250 < int
4251 < main ()
4252 < {
4253 <
4254 <  ;
4255 <  return 0;
4256 < }
4257 < _ACEOF
4258 < 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
4280 <
4281 <        ac_c_werror_flag=$ac_save_c_werror_flag
4282 <         CFLAGS="-g"
4283 <         cat >conftest.$ac_ext <<_ACEOF
4284 < /* confdefs.h.  */
4285 < _ACEOF
4286 < cat confdefs.h >>conftest.$ac_ext
4287 < cat >>conftest.$ac_ext <<_ACEOF
4288 < /* end confdefs.h.  */
4289 <
4290 < int
4291 < main ()
4292 < {
4293 <
4294 <  ;
4295 <  return 0;
4296 < }
4297 < _ACEOF
4298 < 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
4316 <  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 <
4322 < fi
4323 <
4324 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4325 < fi
4326 <
4327 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4328 < fi
4329 <
4330 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4331 <   ac_c_werror_flag=$ac_save_c_werror_flag
4332 < fi
4333 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
4334 < $as_echo "$ac_cv_prog_cc_g" >&6; }
4335 < if test "$ac_test_CFLAGS" = set; then
4336 <  CFLAGS=$ac_save_CFLAGS
4337 < elif test $ac_cv_prog_cc_g = yes; then
4338 <  if test "$GCC" = yes; then
4339 <    CFLAGS="-g -O2"
4340 <  else
4341 <    CFLAGS="-g"
4342 <  fi
4343 < else
4344 <  if test "$GCC" = yes; then
4345 <    CFLAGS="-O2"
4346 <  else
4347 <    CFLAGS=
4348 <  fi
4349 < fi
4350 < { $as_echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
4351 < $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
4352 < if test "${ac_cv_prog_cc_c89+set}" = set; then
4353 <  $as_echo_n "(cached) " >&6
4354 < else
4355 <  ac_cv_prog_cc_c89=no
4356 < ac_save_CC=$CC
4357 < cat >conftest.$ac_ext <<_ACEOF
4358 < /* confdefs.h.  */
4359 < _ACEOF
4360 < cat confdefs.h >>conftest.$ac_ext
4361 < cat >>conftest.$ac_ext <<_ACEOF
4362 < /* end confdefs.h.  */
4363 < #include <stdarg.h>
4364 < #include <stdio.h>
4365 < #include <sys/types.h>
4366 < #include <sys/stat.h>
4367 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
4368 < struct buf { int x; };
4369 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
4370 < static char *e (p, i)
4371 <     char **p;
4372 <     int i;
4373 < {
4374 <  return p[i];
4375 < }
4376 < static char *f (char * (*g) (char **, int), char **p, ...)
4377 < {
4378 <  char *s;
4379 <  va_list v;
4380 <  va_start (v,p);
4381 <  s = g (p, va_arg (v,int));
4382 <  va_end (v);
4383 <  return s;
4384 < }
4385 <
4386 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
4387 <   function prototypes and stuff, but not '\xHH' hex character constants.
4388 <   These don't provoke an error unfortunately, instead are silently treated
4389 <   as 'x'.  The following induces an error, until -std is added to get
4390 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
4391 <   array size at least.  It's necessary to write '\x00'==0 to get something
4392 <   that's true only with -std.  */
4393 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
4394 <
4395 < /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
4396 <   inside strings and character constants.  */
4397 < #define FOO(x) 'x'
4398 < int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
4399 <
4400 < int test (int i, double x);
4401 < struct s1 {int (*f) (int a);};
4402 < struct s2 {int (*f) (double a);};
4403 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
4404 < int argc;
4405 < char **argv;
4406 < int
4407 < main ()
4408 < {
4409 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
4410 <  ;
4411 <  return 0;
4412 < }
4413 < _ACEOF
4414 < for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
4415 <        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4416 < do
4417 <  CC="$ac_save_CC $ac_arg"
4418 <  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
4436 <  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 <
4442 < fi
4443 <
4444 < rm -f core conftest.err conftest.$ac_objext
4445 <  test "x$ac_cv_prog_cc_c89" != "xno" && break
4446 < done
4447 < rm -f conftest.$ac_ext
4448 < CC=$ac_save_CC
4449 <
4450 < fi
4451 < # AC_CACHE_VAL
4452 < case "x$ac_cv_prog_cc_c89" in
4453 <  x)
4454 <    { $as_echo "$as_me:$LINENO: result: none needed" >&5
4455 < $as_echo "none needed" >&6; } ;;
4456 <  xno)
4457 <    { $as_echo "$as_me:$LINENO: result: unsupported" >&5
4458 < $as_echo "unsupported" >&6; } ;;
4459 <  *)
4460 <    CC="$CC $ac_cv_prog_cc_c89"
4461 <    { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
4462 < $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4463 < esac
4464 <
4465 <
4466 < ac_ext=c
4467 < ac_cpp='$CPP $CPPFLAGS'
4468 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4469 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4470 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4471 <
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
4503 <
4504 < 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
4514 <
4515 <
4516 <    test -n "$FC" && break
4517 <  done
4518 < fi
4519 < if test -z "$FC"; then
4520 <  ac_ct_FC=$FC
4521 <  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
4522 < do
4523 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4524 < set dummy $ac_prog; ac_word=$2
4525 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4526 < $as_echo_n "checking for $ac_word... " >&6; }
4527 < if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4528 <  $as_echo_n "(cached) " >&6
4529 < else
4530 <  if test -n "$ac_ct_FC"; then
4531 <  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4532 < else
4533 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4534 < for as_dir in $PATH
4535 < do
4536 <  IFS=$as_save_IFS
4537 <  test -z "$as_dir" && as_dir=.
4538 <  for ac_exec_ext in '' $ac_executable_extensions; do
4539 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4540 <    ac_cv_prog_ac_ct_FC="$ac_prog"
4541 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4542 <    break 2
4543 <  fi
4544 < done
4545 < done
4546 < IFS=$as_save_IFS
4547 <
4548 < fi
4549 < fi
4550 < ac_ct_FC=$ac_cv_prog_ac_ct_FC
4551 < if test -n "$ac_ct_FC"; then
4552 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4553 < $as_echo "$ac_ct_FC" >&6; }
4554 < else
4555 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4556 < $as_echo "no" >&6; }
4557 < fi
4558 <
4559 <
4560 <  test -n "$ac_ct_FC" && break
4561 < done
4562 <
4563 <  if test "x$ac_ct_FC" = x; then
4564 <    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
4579 <
4580 <
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
4619 <
4620 < # If we don't use `.F' as extension, the preprocessor is not run on the
4621 < # input file.  (Note that this only needs to work for GNU compilers.)
4622 < ac_save_ext=$ac_ext
4623 < ac_ext=F
4624 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4625 < $as_echo_n "checking whether we are using the GNU Fortran compiler... " >&6; }
4626 < if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4627 <  $as_echo_n "(cached) " >&6
4628 < else
4629 <  cat >conftest.$ac_ext <<_ACEOF
4630 <      program main
4631 < #ifndef __GNUC__
4632 <       choke me
4633 < #endif
4634 <
4635 <      end
4636 < _ACEOF
4637 < rm -f conftest.$ac_objext
4638 < if { (ac_try="$ac_compile"
4639 < case "(($ac_try" in
4640 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4641 <  *) ac_try_echo=$ac_try;;
4642 < esac
4643 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4644 < $as_echo "$ac_try_echo") >&5
4645 <  (eval "$ac_compile") 2>conftest.er1
4646 <  ac_status=$?
4647 <  grep -v '^ *+' conftest.er1 >conftest.err
4648 <  rm -f conftest.er1
4649 <  cat conftest.err >&5
4650 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4651 <  (exit $ac_status); } && {
4652 <         test -z "$ac_fc_werror_flag" ||
4653 <         test ! -s conftest.err
4654 <       } && test -s conftest.$ac_objext; then
4655 <  ac_compiler_gnu=yes
4656 < else
4657 <  $as_echo "$as_me: failed program was:" >&5
4658 < sed 's/^/| /' conftest.$ac_ext >&5
4659 <
4660 <        ac_compiler_gnu=no
4661 < fi
4662 <
4663 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4664 < ac_cv_fc_compiler_gnu=$ac_compiler_gnu
4665 <
4666 < fi
4667 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
4668 < $as_echo "$ac_cv_fc_compiler_gnu" >&6; }
4669 < ac_ext=$ac_save_ext
4670 < ac_test_FFLAGS=${FCFLAGS+set}
4671 < ac_save_FFLAGS=$FCFLAGS
4672 < FCFLAGS=
4673 < { $as_echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4674 < $as_echo_n "checking whether $FC accepts -g... " >&6; }
4675 < if test "${ac_cv_prog_fc_g+set}" = set; then
4676 <  $as_echo_n "(cached) " >&6
4677 < else
4678 <  FCFLAGS=-g
4679 < cat >conftest.$ac_ext <<_ACEOF
4680 <      program main
4681 <
4682 <      end
4683 < _ACEOF
4684 < rm -f conftest.$ac_objext
4685 < if { (ac_try="$ac_compile"
4686 < case "(($ac_try" in
4687 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4688 <  *) ac_try_echo=$ac_try;;
4689 < esac
4690 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4691 < $as_echo "$ac_try_echo") >&5
4692 <  (eval "$ac_compile") 2>conftest.er1
4693 <  ac_status=$?
4694 <  grep -v '^ *+' conftest.er1 >conftest.err
4695 <  rm -f conftest.er1
4696 <  cat conftest.err >&5
4697 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698 <  (exit $ac_status); } && {
4699 <         test -z "$ac_fc_werror_flag" ||
4700 <         test ! -s conftest.err
4701 <       } && test -s conftest.$ac_objext; then
4702 <  ac_cv_prog_fc_g=yes
4703 < else
4704 <  $as_echo "$as_me: failed program was:" >&5
4705 < sed 's/^/| /' conftest.$ac_ext >&5
4706 <
4707 <        ac_cv_prog_fc_g=no
4708 < fi
4709 <
4710 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4711 <
4712 < fi
4713 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
4714 < $as_echo "$ac_cv_prog_fc_g" >&6; }
4715 < if test "$ac_test_FFLAGS" = set; then
4716 <  FCFLAGS=$ac_save_FFLAGS
4717 < elif test $ac_cv_prog_fc_g = yes; then
4718 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4719 <    FCFLAGS="-g -O2"
4720 <  else
4721 <    FCFLAGS="-g"
4722 <  fi
4723 < else
4724 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4725 <    FCFLAGS="-O2"
4726 <  else
4727 <    FCFLAGS=
4728 <  fi
4729 < fi
4730 <
4731 < ac_ext=c
4732 < ac_cpp='$CPP $CPPFLAGS'
4733 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4734 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4735 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4736 <
4737 < ac_ext=c
4738 < ac_cpp='$CPP $CPPFLAGS'
4739 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4740 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4741 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4742 < { $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
4743 < $as_echo_n "checking how to run the C preprocessor... " >&6; }
4744 < # On Suns, sometimes $CPP names a directory.
4745 < if test -n "$CPP" && test -d "$CPP"; then
4746 <  CPP=
4747 < fi
4748 < if test -z "$CPP"; then
4749 <  if test "${ac_cv_prog_CPP+set}" = set; then
4750 <  $as_echo_n "(cached) " >&6
4751 < else
4752 <      # Double quotes because CPP needs to be expanded
4753 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4754 <    do
4755 <      ac_preproc_ok=false
4756 < for ac_c_preproc_warn_flag in '' yes
4757 < do
4758 <  # Use a header file that comes with gcc, so configuring glibc
4759 <  # with a fresh cross-compiler works.
4760 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4761 <  # <limits.h> exists even on freestanding compilers.
4762 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4763 <  # not just through cpp. "Syntax error" is here to catch this case.
4764 <  cat >conftest.$ac_ext <<_ACEOF
4765 < /* confdefs.h.  */
4766 < _ACEOF
4767 < cat confdefs.h >>conftest.$ac_ext
4768 < cat >>conftest.$ac_ext <<_ACEOF
4769 < /* end confdefs.h.  */
4770 < #ifdef __STDC__
4771 < # include <limits.h>
4772 < #else
4773 < # include <assert.h>
4774 < #endif
4775 <                     Syntax error
4776 < _ACEOF
4777 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4778 < case "(($ac_try" in
4779 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4780 <  *) ac_try_echo=$ac_try;;
4781 < esac
4782 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4783 < $as_echo "$ac_try_echo") >&5
4784 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4785 <  ac_status=$?
4786 <  grep -v '^ *+' conftest.er1 >conftest.err
4787 <  rm -f conftest.er1
4788 <  cat conftest.err >&5
4789 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4790 <  (exit $ac_status); } >/dev/null && {
4791 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4792 <         test ! -s conftest.err
4793 <       }; then
4794 <  :
4795 < else
4796 <  $as_echo "$as_me: failed program was:" >&5
4797 < sed 's/^/| /' conftest.$ac_ext >&5
4798 <
4799 <  # Broken: fails on valid input.
4800 < continue
4801 < fi
4802 <
4803 < rm -f conftest.err conftest.$ac_ext
4804 <
4805 <  # OK, works on sane cases.  Now check whether nonexistent headers
4806 <  # can be detected and how.
4807 <  cat >conftest.$ac_ext <<_ACEOF
4808 < /* confdefs.h.  */
4809 < _ACEOF
4810 < cat confdefs.h >>conftest.$ac_ext
4811 < cat >>conftest.$ac_ext <<_ACEOF
4812 < /* end confdefs.h.  */
4813 < #include <ac_nonexistent.h>
4814 < _ACEOF
4815 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4816 < case "(($ac_try" in
4817 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4818 <  *) ac_try_echo=$ac_try;;
4819 < esac
4820 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4821 < $as_echo "$ac_try_echo") >&5
4822 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4823 <  ac_status=$?
4824 <  grep -v '^ *+' conftest.er1 >conftest.err
4825 <  rm -f conftest.er1
4826 <  cat conftest.err >&5
4827 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4828 <  (exit $ac_status); } >/dev/null && {
4829 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4830 <         test ! -s conftest.err
4831 <       }; then
4832 <  # Broken: success on invalid input.
4833 < continue
4834 < else
4835 <  $as_echo "$as_me: failed program was:" >&5
4836 < sed 's/^/| /' conftest.$ac_ext >&5
4837 <
4838 <  # Passes both tests.
4839 < ac_preproc_ok=:
4840 < break
4841 < fi
4842 <
4843 < rm -f conftest.err conftest.$ac_ext
4844 <
4845 < done
4846 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4847 < rm -f conftest.err conftest.$ac_ext
4848 < if $ac_preproc_ok; then
4849 <  break
4850 < fi
4851 <
4852 <    done
4853 <    ac_cv_prog_CPP=$CPP
4854 <
4855 < fi
4856 <  CPP=$ac_cv_prog_CPP
4857 < else
4858 <  ac_cv_prog_CPP=$CPP
4859 < fi
4860 < { $as_echo "$as_me:$LINENO: result: $CPP" >&5
4861 < $as_echo "$CPP" >&6; }
4862 < ac_preproc_ok=false
4863 < for ac_c_preproc_warn_flag in '' yes
4864 < do
4865 <  # Use a header file that comes with gcc, so configuring glibc
4866 <  # with a fresh cross-compiler works.
4867 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4868 <  # <limits.h> exists even on freestanding compilers.
4869 <  # On the NeXT, cc -E runs the code through the compiler's parser,
4870 <  # not just through cpp. "Syntax error" is here to catch this case.
4871 <  cat >conftest.$ac_ext <<_ACEOF
4872 < /* confdefs.h.  */
4873 < _ACEOF
4874 < cat confdefs.h >>conftest.$ac_ext
4875 < cat >>conftest.$ac_ext <<_ACEOF
4876 < /* end confdefs.h.  */
4877 < #ifdef __STDC__
4878 < # include <limits.h>
4879 < #else
4880 < # include <assert.h>
4881 < #endif
4882 <                     Syntax error
4883 < _ACEOF
4884 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4885 < case "(($ac_try" in
4886 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4887 <  *) ac_try_echo=$ac_try;;
4888 < esac
4889 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4890 < $as_echo "$ac_try_echo") >&5
4891 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4892 <  ac_status=$?
4893 <  grep -v '^ *+' conftest.er1 >conftest.err
4894 <  rm -f conftest.er1
4895 <  cat conftest.err >&5
4896 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4897 <  (exit $ac_status); } >/dev/null && {
4898 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4899 <         test ! -s conftest.err
4900 <       }; then
4901 <  :
4902 < else
4903 <  $as_echo "$as_me: failed program was:" >&5
4904 < sed 's/^/| /' conftest.$ac_ext >&5
4905 <
4906 <  # Broken: fails on valid input.
4907 < continue
4908 < fi
4909 <
4910 < rm -f conftest.err conftest.$ac_ext
4911 <
4912 <  # OK, works on sane cases.  Now check whether nonexistent headers
4913 <  # can be detected and how.
4914 <  cat >conftest.$ac_ext <<_ACEOF
4915 < /* confdefs.h.  */
4916 < _ACEOF
4917 < cat confdefs.h >>conftest.$ac_ext
4918 < cat >>conftest.$ac_ext <<_ACEOF
4919 < /* end confdefs.h.  */
4920 < #include <ac_nonexistent.h>
4921 < _ACEOF
4922 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4923 < case "(($ac_try" in
4924 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4925 <  *) ac_try_echo=$ac_try;;
4926 < esac
4927 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4928 < $as_echo "$ac_try_echo") >&5
4929 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4930 <  ac_status=$?
4931 <  grep -v '^ *+' conftest.er1 >conftest.err
4932 <  rm -f conftest.er1
4933 <  cat conftest.err >&5
4934 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4935 <  (exit $ac_status); } >/dev/null && {
4936 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4937 <         test ! -s conftest.err
4938 <       }; then
4939 <  # Broken: success on invalid input.
4940 < continue
4941 < else
4942 <  $as_echo "$as_me: failed program was:" >&5
4943 < sed 's/^/| /' conftest.$ac_ext >&5
4944 <
4945 <  # Passes both tests.
4946 < ac_preproc_ok=:
4947 < break
4948 < fi
4949 <
4950 < rm -f conftest.err conftest.$ac_ext
4951 <
4952 < done
4953 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4954 < rm -f conftest.err conftest.$ac_ext
4955 < if $ac_preproc_ok; then
4956 <  :
4957 < else
4958 <  { { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
4959 < See \`config.log' for more details." >&5
4960 < $as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
4961 < See \`config.log' for more details." >&2;}
4962 <   { (exit 1); exit 1; }; }
4963 < fi
4964 <
4965 < ac_ext=c
4966 < ac_cpp='$CPP $CPPFLAGS'
4967 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4968 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4969 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4970 <
4971 < { $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
4972 < $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
4973 < if test "${ac_cv_path_GREP+set}" = set; then
4974 <  $as_echo_n "(cached) " >&6
4975 < else
4976 <  if test -z "$GREP"; then
4977 <  ac_path_GREP_found=false
4978 <  # Loop through the user's path and test for each of PROGNAME-LIST
4979 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4980 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4981 < do
4982 <  IFS=$as_save_IFS
4983 <  test -z "$as_dir" && as_dir=.
4984 <  for ac_prog in grep ggrep; do
4985 <    for ac_exec_ext in '' $ac_executable_extensions; do
4986 <      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4987 <      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4988 < # Check for GNU ac_path_GREP and select it if it is found.
4989 <  # Check for GNU $ac_path_GREP
4990 < case `"$ac_path_GREP" --version 2>&1` in
4991 < *GNU*)
4992 <  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4993 < *)
4994 <  ac_count=0
4995 <  $as_echo_n 0123456789 >"conftest.in"
4996 <  while :
4997 <  do
4998 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
4999 <    mv "conftest.tmp" "conftest.in"
5000 <    cp "conftest.in" "conftest.nl"
5001 <    $as_echo 'GREP' >> "conftest.nl"
5002 <    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
5003 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
5004 <    ac_count=`expr $ac_count + 1`
5005 <    if test $ac_count -gt ${ac_path_GREP_max-0}; then
5006 <      # Best one so far, save it but keep looking for a better one
5007 <      ac_cv_path_GREP="$ac_path_GREP"
5008 <      ac_path_GREP_max=$ac_count
5009 <    fi
5010 <    # 10*(2^10) chars as input seems more than enough
5011 <    test $ac_count -gt 10 && break
5012 <  done
5013 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
5014 < esac
5015 <
5016 <      $ac_path_GREP_found && break 3
5017 <    done
5018 <  done
5019 < done
5020 < IFS=$as_save_IFS
5021 <  if test -z "$ac_cv_path_GREP"; then
5022 <    { { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5023 < $as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5024 <   { (exit 1); exit 1; }; }
5025 <  fi
5026 < else
5027 <  ac_cv_path_GREP=$GREP
5028 < fi
5029 <
5030 < fi
5031 < { $as_echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
5032 < $as_echo "$ac_cv_path_GREP" >&6; }
5033 < GREP="$ac_cv_path_GREP"
5034 <
5035 <
5036 < { $as_echo "$as_me:$LINENO: checking for egrep" >&5
5037 < $as_echo_n "checking for egrep... " >&6; }
5038 < if test "${ac_cv_path_EGREP+set}" = set; then
5039 <  $as_echo_n "(cached) " >&6
5040 < else
5041 <  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
5042 <   then ac_cv_path_EGREP="$GREP -E"
5043 <   else
5044 <     if test -z "$EGREP"; then
5045 <  ac_path_EGREP_found=false
5046 <  # Loop through the user's path and test for each of PROGNAME-LIST
5047 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5048 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
5049 < do
5050 <  IFS=$as_save_IFS
5051 <  test -z "$as_dir" && as_dir=.
5052 <  for ac_prog in egrep; do
5053 <    for ac_exec_ext in '' $ac_executable_extensions; do
5054 <      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
5055 <      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
5056 < # Check for GNU ac_path_EGREP and select it if it is found.
5057 <  # Check for GNU $ac_path_EGREP
5058 < case `"$ac_path_EGREP" --version 2>&1` in
5059 < *GNU*)
5060 <  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
5061 < *)
5062 <  ac_count=0
5063 <  $as_echo_n 0123456789 >"conftest.in"
5064 <  while :
5065 <  do
5066 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
5067 <    mv "conftest.tmp" "conftest.in"
5068 <    cp "conftest.in" "conftest.nl"
5069 <    $as_echo 'EGREP' >> "conftest.nl"
5070 <    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
5071 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
5072 <    ac_count=`expr $ac_count + 1`
5073 <    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
5074 <      # Best one so far, save it but keep looking for a better one
5075 <      ac_cv_path_EGREP="$ac_path_EGREP"
5076 <      ac_path_EGREP_max=$ac_count
5077 <    fi
5078 <    # 10*(2^10) chars as input seems more than enough
5079 <    test $ac_count -gt 10 && break
5080 <  done
5081 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
5082 < esac
5083 <
5084 <      $ac_path_EGREP_found && break 3
5085 <    done
5086 <  done
5087 < done
5088 < IFS=$as_save_IFS
5089 <  if test -z "$ac_cv_path_EGREP"; then
5090 <    { { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5091 < $as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5092 <   { (exit 1); exit 1; }; }
5093 <  fi
5094 < else
5095 <  ac_cv_path_EGREP=$EGREP
5096 < fi
5097 <
5098 <   fi
5099 < fi
5100 < { $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
5101 < $as_echo "$ac_cv_path_EGREP" >&6; }
5102 < EGREP="$ac_cv_path_EGREP"
5103 <
5104 <
5105 < { $as_echo "$as_me:$LINENO: checking whether ln -s works" >&5
5106 < $as_echo_n "checking whether ln -s works... " >&6; }
5107 < LN_S=$as_ln_s
5108 < if test "$LN_S" = "ln -s"; then
5109 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
5110 < $as_echo "yes" >&6; }
5111 < else
5112 <  { $as_echo "$as_me:$LINENO: result: no, using $LN_S" >&5
5113 < $as_echo "no, using $LN_S" >&6; }
5114 < fi
5115 <
5116 < { $as_echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
5117 < $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
5118 < set x ${MAKE-make}
5119 < ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
5120 < if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
5121 <  $as_echo_n "(cached) " >&6
5122 < else
5123 <  cat >conftest.make <<\_ACEOF
5124 < SHELL = /bin/sh
5125 < all:
5126 <        @echo '@@@%%%=$(MAKE)=@@@%%%'
5127 < _ACEOF
5128 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
5129 < case `${MAKE-make} -f conftest.make 2>/dev/null` in
5130 <  *@@@%%%=?*=@@@%%%*)
5131 <    eval ac_cv_prog_make_${ac_make}_set=yes;;
5132 <  *)
5133 <    eval ac_cv_prog_make_${ac_make}_set=no;;
5134 < esac
5135 < rm -f conftest.make
5136 < fi
5137 < if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
5138 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
5139 < $as_echo "yes" >&6; }
5140 <  SET_MAKE=
5141 < else
5142 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5143 < $as_echo "no" >&6; }
5144 <  SET_MAKE="MAKE=${MAKE-make}"
5145 < fi
5146 <
5147 < if test -n "$ac_tool_prefix"; then
5148 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
5149 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
5150 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5151 < $as_echo_n "checking for $ac_word... " >&6; }
5152 < if test "${ac_cv_prog_RANLIB+set}" = set; then
5153 <  $as_echo_n "(cached) " >&6
5154 < else
5155 <  if test -n "$RANLIB"; then
5156 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
5157 < else
5158 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5159 < for as_dir in $PATH
5160 < do
5161 <  IFS=$as_save_IFS
5162 <  test -z "$as_dir" && as_dir=.
5163 <  for ac_exec_ext in '' $ac_executable_extensions; do
5164 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5165 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
5166 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5167 <    break 2
5168 <  fi
5169 < done
5170 < done
5171 < IFS=$as_save_IFS
5172 <
5173 < fi
5174 < fi
5175 < RANLIB=$ac_cv_prog_RANLIB
5176 < if test -n "$RANLIB"; then
5177 <  { $as_echo "$as_me:$LINENO: result: $RANLIB" >&5
5178 < $as_echo "$RANLIB" >&6; }
5179 < else
5180 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5181 < $as_echo "no" >&6; }
5182 < fi
5183 <
5184 <
5185 < fi
5186 < if test -z "$ac_cv_prog_RANLIB"; then
5187 <  ac_ct_RANLIB=$RANLIB
5188 <  # Extract the first word of "ranlib", so it can be a program name with args.
5189 < set dummy ranlib; ac_word=$2
5190 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5191 < $as_echo_n "checking for $ac_word... " >&6; }
5192 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
5193 <  $as_echo_n "(cached) " >&6
5194 < else
5195 <  if test -n "$ac_ct_RANLIB"; then
5196 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
5197 < else
5198 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5199 < for as_dir in $PATH
5200 < do
5201 <  IFS=$as_save_IFS
5202 <  test -z "$as_dir" && as_dir=.
5203 <  for ac_exec_ext in '' $ac_executable_extensions; do
5204 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5205 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
5206 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5207 <    break 2
5208 <  fi
5209 < done
5210 < done
5211 < IFS=$as_save_IFS
5212 <
5213 < fi
5214 < fi
5215 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
5216 < if test -n "$ac_ct_RANLIB"; then
5217 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
5218 < $as_echo "$ac_ct_RANLIB" >&6; }
5219 < else
5220 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5221 < $as_echo "no" >&6; }
5222 < fi
5223 <
5224 <  if test "x$ac_ct_RANLIB" = x; then
5225 <    RANLIB=":"
5226 <  else
5227 <    case $cross_compiling:$ac_tool_warned in
5228 < yes:)
5229 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
5230 < whose name does not start with the host triplet.  If you think this
5231 < configuration is useful to you, please write to autoconf@gnu.org." >&5
5232 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
5233 < whose name does not start with the host triplet.  If you think this
5234 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
5235 < ac_tool_warned=yes ;;
5236 < esac
5237 <    RANLIB=$ac_ct_RANLIB
5238 <  fi
5239 < else
5240 <  RANLIB="$ac_cv_prog_RANLIB"
5241 < fi
5242 <
5243 <
5244 <   # Extract the first word of "perl", so it can be a program name with args.
5245 < set dummy perl; ac_word=$2
5246 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5247 < $as_echo_n "checking for $ac_word... " >&6; }
5248 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
5249 <  $as_echo_n "(cached) " >&6
5250 < else
5251 <  case $PERLINTERP in
5252 <  [\\/]* | ?:[\\/]*)
5253 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
5254 <  ;;
5255 <  *)
5256 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5257 < for as_dir in $PATH
5258 < do
5259 <  IFS=$as_save_IFS
5260 <  test -z "$as_dir" && as_dir=.
5261 <  for ac_exec_ext in '' $ac_executable_extensions; do
5262 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5263 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
5264 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5265 <    break 2
5266 <  fi
5267 < done
5268 < done
5269 < IFS=$as_save_IFS
5270 <
5271 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
5272 <  ;;
5273 < esac
5274 < fi
5275 < PERLINTERP=$ac_cv_path_PERLINTERP
5276 < if test -n "$PERLINTERP"; then
5277 <  { $as_echo "$as_me:$LINENO: result: $PERLINTERP" >&5
5278 < $as_echo "$PERLINTERP" >&6; }
5279 < else
5280 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5281 < $as_echo "no" >&6; }
5282 < fi
5283 <
5284 <
5285 <   ac_cv_path_perlinterp="$PERLINTERP"
5286 <   _sHpB='#!'
5287 <
5288 <
5289 < # Check whether --with-perl-shebang was given.
5290 < if test "${with_perl_shebang+set}" = set; then
5291 <  withval=$with_perl_shebang; opt_perl_shebang="$withval"
5292 < else
5293 <                opt_perl_shebang="not_set"
5294 < fi
5295 <
5296 <   { $as_echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
5297 < $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
5298 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
5299 <  $as_echo_n "(cached) " >&6
5300 < else
5301 <   case "$opt_perl_shebang" in
5302 <                      not_set  ) ax_cv_opt_perl_shebang=''
5303 <                               ;;
5304 <                         *     )
5305 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
5306 <                    esac
5307 <
5308 < fi
5309 < { $as_echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
5310 < $as_echo "$ax_cv_opt_perl_shebang" >&6; }
5311 <   if test "A$ax_cv_opt_perl_shebang" != "A"
5312 <     then
5313 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
5314 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
5315 <              { $as_echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
5316 < $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
5317 <
5318 < # Automatic detection of sharpbang formula starts here
5319 <     else
5320 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
5321 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
5322 <   { $as_echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
5323 < $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
5324 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
5325 <  $as_echo_n "(cached) " >&6
5326 < else
5327 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
5328 <        if test "x$_somian_kspb_perl" == x
5329 <          then _somian_ksbp_warn_empty='durnit'
5330 <          else
5331 <          case "A$_somian_kspb_perl" in
5332 <                 A#!*perl* )
5333 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
5334 <                        ;;
5335 <                     A*    )  _somian_ksbp_warn_defau='trouble'
5336 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
5337 <          esac
5338 <        fi
5339 <
5340 < fi
5341 < { $as_echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
5342 < $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
5343 < # The above prints Checking ... result message to user.
5344 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
5345 <
5346 <    if test A${_somian_ksbp_warn_empty+set} == Aset
5347 <      then   { $as_echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
5348 < $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
5349 <    fi
5350 < # Inform user after printing result value
5351 <    if test A${_somian_ksbp_warn_defau+set} == Aset
5352 <      then { $as_echo "$as_me:$LINENO: Maybe Not good -" >&5
5353 < $as_echo "$as_me: Maybe Not good -" >&6;}
5354 <           { $as_echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
5355 < $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
5356 <      else { $as_echo "$as_me:$LINENO: OK Good result - " >&5
5357 < $as_echo "$as_me: OK Good result - " >&6;}
5358 <           { $as_echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
5359 < $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
5360 <    fi
5361 <  fi
5362 <
5363 < # Find a good install program.  We prefer a C program (faster),
5364 < # so one script is as good as another.  But avoid the broken or
5365 < # incompatible versions:
5366 < # SysV /etc/install, /usr/sbin/install
5367 < # SunOS /usr/etc/install
5368 < # IRIX /sbin/install
5369 < # AIX /bin/install
5370 < # AmigaOS /C/install, which installs bootblocks on floppy discs
5371 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
5372 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
5373 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
5374 < # OS/2's system install, which has a completely different semantic
5375 < # ./install, which can be erroneously created by make from ./install.sh.
5376 < # Reject install programs that cannot install multiple files.
5377 < { $as_echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
5378 < $as_echo_n "checking for a BSD-compatible install... " >&6; }
5379 < if test -z "$INSTALL"; then
5380 < if test "${ac_cv_path_install+set}" = set; then
5381 <  $as_echo_n "(cached) " >&6
5382 < else
5383 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5384 < for as_dir in $PATH
5385 < do
5386 <  IFS=$as_save_IFS
5387 <  test -z "$as_dir" && as_dir=.
5388 <  # Account for people who put trailing slashes in PATH elements.
5389 < case $as_dir/ in
5390 <  ./ | .// | /cC/* | \
5391 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
5392 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
5393 <  /usr/ucb/* ) ;;
5394 <  *)
5395 <    # OSF1 and SCO ODT 3.0 have their own names for install.
5396 <    # Don't use installbsd from OSF since it installs stuff as root
5397 <    # by default.
5398 <    for ac_prog in ginstall scoinst install; do
5399 <      for ac_exec_ext in '' $ac_executable_extensions; do
5400 <        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
5401 <          if test $ac_prog = install &&
5402 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
5403 <            # AIX install.  It has an incompatible calling convention.
5404 <            :
5405 <          elif test $ac_prog = install &&
5406 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
5407 <            # program-specific install script used by HP pwplus--don't use.
5408 <            :
5409 <          else
5410 <            rm -rf conftest.one conftest.two conftest.dir
5411 <            echo one > conftest.one
5412 <            echo two > conftest.two
5413 <            mkdir conftest.dir
5414 <            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
5415 <              test -s conftest.one && test -s conftest.two &&
5416 <              test -s conftest.dir/conftest.one &&
5417 <              test -s conftest.dir/conftest.two
5418 <            then
5419 <              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
5420 <              break 3
5421 <            fi
5422 <          fi
5423 <        fi
5424 <      done
5425 <    done
5426 <    ;;
5427 < esac
5428 <
5429 < done
5430 < IFS=$as_save_IFS
5431 <
5432 < rm -rf conftest.one conftest.two conftest.dir
5433 <
5434 < fi
5435 <  if test "${ac_cv_path_install+set}" = set; then
5436 <    INSTALL=$ac_cv_path_install
5437 <  else
5438 <    # As a last resort, use the slow shell script.  Don't cache a
5439 <    # value for INSTALL within a source directory, because that will
5440 <    # break other packages using the cache if that directory is
5441 <    # removed, or if the value is a relative name.
5442 <    INSTALL=$ac_install_sh
5443 <  fi
5444 < fi
5445 < { $as_echo "$as_me:$LINENO: result: $INSTALL" >&5
5446 < $as_echo "$INSTALL" >&6; }
5447 <
5448 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
5449 < # It thinks the first close brace ends the variable substitution.
5450 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
5451 <
5452 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
5453 <
5454 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
5455 <
5456 < case "x$INSTALL" in
5457 <   x/*) ;;
5458 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
5459 < esac
5460 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
5461 < # Extract the first word of "ar", so it can be a program name with args.
5462 < set dummy ar; ac_word=$2
5463 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5464 < $as_echo_n "checking for $ac_word... " >&6; }
5465 < if test "${ac_cv_prog_AR+set}" = set; then
5466 <  $as_echo_n "(cached) " >&6
5467 < else
5468 <  if test -n "$AR"; then
5469 <  ac_cv_prog_AR="$AR" # Let the user override the test.
5470 < else
5471 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5472 < for as_dir in $PATH
5473 < do
5474 <  IFS=$as_save_IFS
5475 <  test -z "$as_dir" && as_dir=.
5476 <  for ac_exec_ext in '' $ac_executable_extensions; do
5477 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5478 <    ac_cv_prog_AR="ar"
5479 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5480 <    break 2
5481 <  fi
5482 < done
5483 < done
5484 < IFS=$as_save_IFS
5485 <
5486 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
5487 < fi
5488 < fi
5489 < AR=$ac_cv_prog_AR
5490 < if test -n "$AR"; then
5491 <  { $as_echo "$as_me:$LINENO: result: $AR" >&5
5492 < $as_echo "$AR" >&6; }
5493 < else
5494 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5495 < $as_echo "no" >&6; }
5496 < fi
5497 <
5498 <
5499 < if test "$AR" = "NONE"; then
5500 <  cat >confcache <<\_ACEOF
5501 < # This file is a shell script that caches the results of configure
5502 < # tests run on this system so they can be shared between configure
5503 < # scripts and configure runs, see configure's option --config-cache.
5504 < # It is not useful on other systems.  If it contains results you don't
5505 < # want to keep, you may remove or edit it.
5506 < #
5507 < # config.status only pays attention to the cache file if you give it
5508 < # the --recheck option to rerun configure.
5509 < #
5510 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
5511 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
5512 < # following values.
5513 <
5514 < _ACEOF
5515 <
5516 < # The following way of writing the cache mishandles newlines in values,
5517 < # but we know of no workaround that is simple, portable, and efficient.
5518 < # So, we kill variables containing newlines.
5519 < # Ultrix sh set writes to stderr and can't be redirected directly,
5520 < # and sets the high bit in the cache file unless we assign to the vars.
5521 < (
5522 <  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
5523 <    eval ac_val=\$$ac_var
5524 <    case $ac_val in #(
5525 <    *${as_nl}*)
5526 <      case $ac_var in #(
5527 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
5528 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
5529 <      esac
5530 <      case $ac_var in #(
5531 <      _ | IFS | as_nl) ;; #(
5532 <      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
5533 <      *) $as_unset $ac_var ;;
5534 <      esac ;;
5535 <    esac
5536 <  done
5537 <
5538 <  (set) 2>&1 |
5539 <    case $as_nl`(ac_space=' '; set) 2>&1` in #(
5540 <    *${as_nl}ac_space=\ *)
5541 <      # `set' does not quote correctly, so add quotes (double-quote
5542 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
5543 <      sed -n \
5544 <        "s/'/'\\\\''/g;
5545 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
5546 <      ;; #(
5547 <    *)
5548 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
5549 <      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
5550 <      ;;
5551 <    esac |
5552 <    sort
5553 < ) |
5554 <  sed '
5555 <     /^ac_cv_env_/b end
5556 <     t clear
5557 <     :clear
5558 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
5559 <     t end
5560 <     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
5561 <     :end' >>confcache
5562 < if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
5563 <  if test -w "$cache_file"; then
5564 <    test "x$cache_file" != "x/dev/null" &&
5565 <      { $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
5566 < $as_echo "$as_me: updating cache $cache_file" >&6;}
5567 <    cat confcache >$cache_file
5568 <  else
5569 <    { $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
5570 < $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
5571 <  fi
5572 < fi
5573 < rm -f confcache
5574 <  exit 1
5575 < fi
5576 < # Extract the first word of "ps", so it can be a program name with args.
5577 < set dummy ps; ac_word=$2
5578 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5579 < $as_echo_n "checking for $ac_word... " >&6; }
5580 < if test "${ac_cv_path_PS+set}" = set; then
5581 <  $as_echo_n "(cached) " >&6
5582 < else
5583 <  case $PS in
5584 <  [\\/]* | ?:[\\/]*)
5585 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
5586 <  ;;
5587 <  *)
5588 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5589 < for as_dir in $PATH
5590 < do
5591 <  IFS=$as_save_IFS
5592 <  test -z "$as_dir" && as_dir=.
5593 <  for ac_exec_ext in '' $ac_executable_extensions; do
5594 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5595 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
5596 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5597 <    break 2
5598 <  fi
5599 < done
5600 < done
5601 < IFS=$as_save_IFS
5602 <
5603 <  ;;
5604 < esac
5605 < fi
5606 < PS=$ac_cv_path_PS
5607 < if test -n "$PS"; then
5608 <  { $as_echo "$as_me:$LINENO: result: $PS" >&5
5609 < $as_echo "$PS" >&6; }
5610 < else
5611 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5612 < $as_echo "no" >&6; }
5613 < fi
5614 <
5615 <
5616 < { $as_echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
5617 < $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
5618 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
5619 <  $as_echo_n "(cached) " >&6
5620 < else
5621 <
5622 <        if $PS ax -o rss > /dev/null 2>&1; then
5623 <                ac_cv_prog_ps_ax=yes
5624 <        else
5625 <                ac_cv_prog_ps_ax=no
5626 <        fi
5627 <        if $PS -ef -o rss > /dev/null 2>&1; then
5628 <                ac_cv_prog_ps_ef=yes
5629 <        else
5630 <                ac_cv_prog_ps_ef=no
5631 <        fi
5632 <        if test "$ac_cv_prog_ps_ax" = yes; then
5633 <                ac_cv_prog_ps_syntax=BSD
5634 <        else
5635 <                if test "$ac_cv_prog_ps_ef" = yes; then
5636 <                        ac_cv_prog_ps_syntax=POSIX
5637 <                else
5638 <                        { { $as_echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
5639 < $as_echo "$as_me: error: Could not determine ps syntax" >&2;}
5640 <   { (exit 1); exit 1; }; }
5641 <                fi
5642 <        fi
5643 <
5644 < fi
5645 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
5646 < $as_echo "$ac_cv_prog_ps_syntax" >&6; }
5647 <
5648 < cat >>confdefs.h <<_ACEOF
5649 < #define PSCOMMAND $PS
5650 < _ACEOF
5651 <
5652 < if test "$ac_cv_prog_ps_syntax" = BSD; then
5653 <
5654 < cat >>confdefs.h <<\_ACEOF
5655 < #define PSTYPE_IS_BSD 1
5656 < _ACEOF
5657 <
5658 < else
5659 <   if test "$ac_cv_prog_ps_syntax" = POSIX; then
5660 <
5661 < cat >>confdefs.h <<\_ACEOF
5662 < #define PSTYPE_IS_POSIX 1
5663 < _ACEOF
5664 <
5665 <   else
5666 <       { { $as_echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
5667 < $as_echo "$as_me: error: Unknown ps syntax type!" >&2;}
5668 <   { (exit 1); exit 1; }; }
5669 <   fi
5670 < fi
5671 <
5672 < ac_ext=${ac_fc_srcext-f}
5673 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5674 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5675 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5676 <
5677 <
5678 < ac_ext=${ac_fc_srcext-f}
5679 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5680 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5681 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5682 < { $as_echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
5683 < $as_echo_n "checking for Fortran flag to compile .F90 files... " >&6; }
5684 < if test "${ac_cv_fc_srcext_F90+set}" = set; then
5685 <  $as_echo_n "(cached) " >&6
5686 < else
5687 <  ac_ext=F90
5688 < ac_fcflags_srcext_save=$ac_fcflags_srcext
5689 < ac_fcflags_srcext=
5690 < ac_cv_fc_srcext_F90=unknown
5691 < for ac_flag in none -qsuffix=f=F90 -Tf; do
5692 <  test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
5693 <  cat >conftest.$ac_ext <<_ACEOF
5694 <      program main
5695 <
5696 <      end
5697 < _ACEOF
5698 < rm -f conftest.$ac_objext
5699 < if { (ac_try="$ac_compile"
5700 < case "(($ac_try" in
5701 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5702 <  *) ac_try_echo=$ac_try;;
5703 < esac
5704 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5705 < $as_echo "$ac_try_echo") >&5
5706 <  (eval "$ac_compile") 2>conftest.er1
5707 <  ac_status=$?
5708 <  grep -v '^ *+' conftest.er1 >conftest.err
5709 <  rm -f conftest.er1
5710 <  cat conftest.err >&5
5711 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5712 <  (exit $ac_status); } && {
5713 <         test -z "$ac_fc_werror_flag" ||
5714 <         test ! -s conftest.err
5715 <       } && test -s conftest.$ac_objext; then
5716 <  ac_cv_fc_srcext_F90=$ac_flag; break
5717 < else
5718 <  $as_echo "$as_me: failed program was:" >&5
5719 < sed 's/^/| /' conftest.$ac_ext >&5
5720 <
5721 <
5722 < fi
5723 <
5724 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5725 < done
5726 < rm -f conftest.$ac_objext conftest.F90
5727 < ac_fcflags_srcext=$ac_fcflags_srcext_save
5728 <
5729 < fi
5730 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
5731 < $as_echo "$ac_cv_fc_srcext_F90" >&6; }
5732 < if test "x$ac_cv_fc_srcext_F90" = xunknown; then
5733 <  { { $as_echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
5734 < $as_echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
5735 <   { (exit 1); exit 1; }; }
5736 < else
5737 <  ac_fc_srcext=F90
5738 <  if test "x$ac_cv_fc_srcext_F90" = xnone; then
5739 <    ac_fcflags_srcext=""
5740 <    FCFLAGS_F90=""
5741 <  else
5742 <    ac_fcflags_srcext=$ac_cv_fc_srcext_F90
5743 <    FCFLAGS_F90=$ac_cv_fc_srcext_F90
5744 <  fi
5745 <
5746 <
5747 < fi
5748 < ac_ext=${ac_fc_srcext-f}
5749 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5750 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5751 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5752 <
5753 <
5754 <
5755 <
5756 <
5757 < # Try to determine native compiler flags that allow us to use F90 suffix
5758 < # for preprocessed f90 source.
5759 <
5760 < if test "$ac_test_PREPFLAG" != "set"; then
5761 <  PREPFLAG=""
5762 <  case "${host_cpu}-${host_os}" in
5763 <
5764 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5765 <                    PREPFLAG="-fpp1 "
5766 <                fi;;
5767 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
5768 <                    PREPFLAG="-qsuffix=cpp=F90 "
5769 <                fi;;
5770 <  *darwin*)
5771 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
5772 <                PREPFLAG="-qsuffix=cpp=F90 "
5773 <        fi;;
5774 <  esac
5775 <
5776 <  if test -z "$PREPFLAG"; then
5777 <        { $as_echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
5778 < $as_echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
5779 <        PREPFLAG=""
5780 <  fi
5781 <
5782 <  { $as_echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
5783 < $as_echo_n "checking to make sure F90 preprocessor flag works... " >&6; }
5784 <
5785 <  ac_ext=${ac_fc_srcext-f}
5786 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5787 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5788 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5789 <
5790 <  ac_save_ext=$ac_ext
5791 <  ac_ext=F90
5792 <  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
5793 <
5794 <  if test "$PREPFLAG"; then
5795 <  FCFLAGS_SRCEXT="${PREPFLAG}"
5796 < fi
5797 <
5798 <    cat >conftest.$ac_ext <<_ACEOF
5799 <
5800 <
5801 < program conftest
5802 <  integer :: i
5803 <  i = 1
5804 < end program conftest
5805 <
5806 < _ACEOF
5807 < rm -f conftest.$ac_objext
5808 < if { (ac_try="$ac_compile"
5809 < case "(($ac_try" in
5810 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5811 <  *) ac_try_echo=$ac_try;;
5812 < esac
5813 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5814 < $as_echo "$ac_try_echo") >&5
5815 <  (eval "$ac_compile") 2>conftest.er1
5816 <  ac_status=$?
5817 <  grep -v '^ *+' conftest.er1 >conftest.err
5818 <  rm -f conftest.er1
5819 <  cat conftest.err >&5
5820 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5821 <  (exit $ac_status); } && {
5822 <         test -z "$ac_fc_werror_flag" ||
5823 <         test ! -s conftest.err
5824 <       } && test -s conftest.$ac_objext; then
5825 <  prepflagworks=1
5826 < else
5827 <  $as_echo "$as_me: failed program was:" >&5
5828 < sed 's/^/| /' conftest.$ac_ext >&5
5829 <
5830 <        prepflagworks=0
5831 < fi
5832 <
5833 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5834 <
5835 <  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
5836 <  ac_ext=$ac_save_ext
5837 <  ac_ext=${ac_fc_srcext-f}
5838 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5839 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5840 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5841 <
5842 <
5843 <  if test "$prepflagworks" = 1; then
5844 <    { $as_echo "$as_me:$LINENO: result: yes" >&5
5845 < $as_echo "yes" >&6; }
5846 <    FCFLAGS_SRCEXT="${PREPFLAG}"
5847 <
5848 <  else
5849 <    { $as_echo "$as_me:$LINENO: result: no" >&5
5850 < $as_echo "no" >&6; }
5851 <    { { $as_echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
5852 < $as_echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
5853 <   { (exit 1); exit 1; }; }
5854 <  fi
5855 < fi
5856 <
5857 <
5858 <
5859 <
5860 <
5861 < # Try to determine native compiler flags that allow us to use F90 suffix
5862 < # for preprocessed f90 source with -D type defines
5863 <
5864 < if test "$ac_test_PREPDEFFLAG" != "set"; then
5865 <  PREPDEFFLAG=""
5866 <  case "${host_cpu}-${host_os}" in
5867 <
5868 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5869 <                    PREPDEFFLAG=" "
5870 <                fi;;
5871 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
5872 <                    PREPDEFFLAG="-WF,"
5873 <                fi;;
5874 <  *darwin*)
5875 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
5876 <                PREPDEFFLAG="-WF,"
5877 <        fi;;
5878 <  esac
5879 <
5880 <  if test -z "$PREPDEFFLAG"; then
5881 <        { $as_echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
5882 < $as_echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
5883 <        PREPDEFFLAG=" "
5884 <  fi
5885 <
5886 <  { $as_echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
5887 < $as_echo_n "checking to make sure F90 preprocessor define flag works... " >&6; }
5888 <
5889 <  ac_ext=${ac_fc_srcext-f}
5890 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5891 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5892 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5893 <
5894 <  ac_save_ext=$ac_ext
5895 <  ac_ext=F90
5896 <  ac_save_FCFLAGS=$FCFLAGS
5897 <
5898 <  if test "$PREPDEFFLAG"; then
5899 <  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
5900 < fi
5901 <
5902 <    cat >conftest.$ac_ext <<_ACEOF
5903 <
5904 <
5905 < program conftest
5906 <  integer :: i
5907 < #ifdef TEST
5908 <  i = 1
5909 < #else
5910 <  choke me
5911 < #endif
5912 < end program conftest
5913 <
5914 < _ACEOF
5915 < rm -f conftest.$ac_objext
5916 < if { (ac_try="$ac_compile"
5917 < case "(($ac_try" in
5918 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5919 <  *) ac_try_echo=$ac_try;;
5920 < esac
5921 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5922 < $as_echo "$ac_try_echo") >&5
5923 <  (eval "$ac_compile") 2>conftest.er1
5924 <  ac_status=$?
5925 <  grep -v '^ *+' conftest.er1 >conftest.err
5926 <  rm -f conftest.er1
5927 <  cat conftest.err >&5
5928 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5929 <  (exit $ac_status); } && {
5930 <         test -z "$ac_fc_werror_flag" ||
5931 <         test ! -s conftest.err
5932 <       } && test -s conftest.$ac_objext; then
5933 <  prepdefflagworks=1
5934 < else
5935 <  $as_echo "$as_me: failed program was:" >&5
5936 < sed 's/^/| /' conftest.$ac_ext >&5
5937 <
5938 <        prepdefflagworks=0
5939 < fi
5940 <
5941 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5942 <
5943 <  FCFLAGS=$ac_save_FCFLAGS
5944 <  ac_ext=$ac_save_ext
5945 <  ac_ext=${ac_fc_srcext-f}
5946 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5947 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5948 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5949 <
5950 <
5951 <  if test "$prepdefflagworks" = 1; then
5952 <    { $as_echo "$as_me:$LINENO: result: yes" >&5
5953 < $as_echo "yes" >&6; }
5954 <
5955 <  else
5956 <    { $as_echo "$as_me:$LINENO: result: no" >&5
5957 < $as_echo "no" >&6; }
5958 <    { { $as_echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
5959 < $as_echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
5960 <   { (exit 1); exit 1; }; }
5961 <  fi
5962 < fi
5963 <
5964 < ac_ext=${ac_fc_srcext-f}
5965 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5966 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5967 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5968 < { $as_echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
5969 < $as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
5970 < if test "${ac_cv_prog_fc_v+set}" = set; then
5971 <  $as_echo_n "(cached) " >&6
5972 < else
5973 <  cat >conftest.$ac_ext <<_ACEOF
5974 <      program main
5975 <
5976 <      end
5977 < _ACEOF
5978 < rm -f conftest.$ac_objext
5979 < if { (ac_try="$ac_compile"
5980 < case "(($ac_try" in
5981 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5982 <  *) ac_try_echo=$ac_try;;
5983 < esac
5984 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
5985 < $as_echo "$ac_try_echo") >&5
5986 <  (eval "$ac_compile") 2>conftest.er1
5987 <  ac_status=$?
5988 <  grep -v '^ *+' conftest.er1 >conftest.err
5989 <  rm -f conftest.er1
5990 <  cat conftest.err >&5
5991 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
5992 <  (exit $ac_status); } && {
5993 <         test -z "$ac_fc_werror_flag" ||
5994 <         test ! -s conftest.err
5995 <       } && test -s conftest.$ac_objext; then
5996 <  ac_cv_prog_fc_v=
5997 < # Try some options frequently used verbose output
5998 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
5999 <  cat >conftest.$ac_ext <<_ACEOF
6000 <      program main
6001 <
6002 <      end
6003 < _ACEOF
6004 <
6005 < # Compile and link our simple test program by passing a flag (argument
6006 < # 1 to this macro) to the Fortran compiler in order to get
6007 < # "verbose" output that we can then parse for the Fortran linker
6008 < # flags.
6009 < ac_save_FFLAGS=$FCFLAGS
6010 < FCFLAGS="$FCFLAGS $ac_verb"
6011 < eval "set x $ac_link"
6012 < shift
6013 < $as_echo "$as_me:$LINENO: $*" >&5
6014 < # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
6015 < # LIBRARY_PATH; skip all such settings.
6016 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
6017 <  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
6018 < $as_echo "$ac_fc_v_output" >&5
6019 < FCFLAGS=$ac_save_FFLAGS
6020 <
6021 < rm -rf conftest*
6022 <
6023 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6024 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6025 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6026 < ac_fc_v_output="`echo $ac_fc_v_output |
6027 <        grep 'LPATH is:' |
6028 <        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
6029 <
6030 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6031 < #        that detects unbalanced quotes in FLIBS should be implemented
6032 < #        and (ugh) tested at some point.
6033 < case $ac_fc_v_output in
6034 <  # If we are using xlf then replace all the commas with spaces.
6035 <  *xlfentry*)
6036 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6037 <
6038 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6039 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6040 <  *mGLOB_options_string*)
6041 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6042 <
6043 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6044 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6045 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6046 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6047 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6048 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6049 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6050 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6051 <
6052 <  # If we are using Cray Fortran then delete quotes.
6053 <  *cft90*)
6054 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6055 < esac
6056 <
6057 <
6058 <  # look for -l* and *.a constructs in the output
6059 <  for ac_arg in $ac_fc_v_output; do
6060 <     case $ac_arg in
6061 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
6062 <          ac_cv_prog_fc_v=$ac_verb
6063 <          break 2 ;;
6064 <     esac
6065 <  done
6066 < done
6067 < if test -z "$ac_cv_prog_fc_v"; then
6068 <   { $as_echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
6069 < $as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
6070 < fi
6071 < else
6072 <  $as_echo "$as_me: failed program was:" >&5
6073 < sed 's/^/| /' conftest.$ac_ext >&5
6074 <
6075 <        { $as_echo "$as_me:$LINENO: WARNING: compilation failed" >&5
6076 < $as_echo "$as_me: WARNING: compilation failed" >&2;}
6077 < fi
6078 <
6079 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6080 <
6081 < fi
6082 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
6083 < $as_echo "$ac_cv_prog_fc_v" >&6; }
6084 < { $as_echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
6085 < $as_echo_n "checking for Fortran libraries of $FC... " >&6; }
6086 < if test "${ac_cv_fc_libs+set}" = set; then
6087 <  $as_echo_n "(cached) " >&6
6088 < else
6089 <  if test "x$FCLIBS" != "x"; then
6090 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
6091 < else
6092 <
6093 < cat >conftest.$ac_ext <<_ACEOF
6094 <      program main
6095 <
6096 <      end
6097 < _ACEOF
6098 <
6099 < # Compile and link our simple test program by passing a flag (argument
6100 < # 1 to this macro) to the Fortran compiler in order to get
6101 < # "verbose" output that we can then parse for the Fortran linker
6102 < # flags.
6103 < ac_save_FFLAGS=$FCFLAGS
6104 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
6105 < eval "set x $ac_link"
6106 < shift
6107 < $as_echo "$as_me:$LINENO: $*" >&5
6108 < # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
6109 < # LIBRARY_PATH; skip all such settings.
6110 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
6111 <  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
6112 < $as_echo "$ac_fc_v_output" >&5
6113 < FCFLAGS=$ac_save_FFLAGS
6114 <
6115 < rm -rf conftest*
6116 <
6117 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6118 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6119 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6120 < ac_fc_v_output="`echo $ac_fc_v_output |
6121 <        grep 'LPATH is:' |
6122 <        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
6123 <
6124 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6125 < #        that detects unbalanced quotes in FLIBS should be implemented
6126 < #        and (ugh) tested at some point.
6127 < case $ac_fc_v_output in
6128 <  # If we are using xlf then replace all the commas with spaces.
6129 <  *xlfentry*)
6130 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6131 <
6132 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6133 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6134 <  *mGLOB_options_string*)
6135 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6136 <
6137 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6138 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6139 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6140 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6141 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6142 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6143 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6144 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6145 <
6146 <  # If we are using Cray Fortran then delete quotes.
6147 <  *cft90*)
6148 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6149 < esac
6150 <
6151 <
6152 <
6153 < ac_cv_fc_libs=
6154 <
6155 < # Save positional arguments (if any)
6156 < ac_save_positional="$@"
6157 <
6158 < set X $ac_fc_v_output
6159 < while test $# != 1; do
6160 <  shift
6161 <  ac_arg=$1
6162 <  case $ac_arg in
6163 <        [\\/]*.a | ?:[\\/]*.a)
6164 <            ac_exists=false
6165 <  for ac_i in $ac_cv_fc_libs; do
6166 <    if test x"$ac_arg" = x"$ac_i"; then
6167 <      ac_exists=true
6168 <      break
6169 <    fi
6170 <  done
6171 <
6172 <  if test x"$ac_exists" = xtrue; then
6173 <  :
6174 < else
6175 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6176 < fi
6177 <
6178 <          ;;
6179 <        -bI:*)
6180 <            ac_exists=false
6181 <  for ac_i in $ac_cv_fc_libs; do
6182 <    if test x"$ac_arg" = x"$ac_i"; then
6183 <      ac_exists=true
6184 <      break
6185 <    fi
6186 <  done
6187 <
6188 <  if test x"$ac_exists" = xtrue; then
6189 <  :
6190 < else
6191 <  if test "$ac_compiler_gnu" = yes; then
6192 <  for ac_link_opt in $ac_arg; do
6193 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6194 <  done
6195 < else
6196 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6197 < fi
6198 < fi
6199 <
6200 <          ;;
6201 <          # Ignore these flags.
6202 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
6203 <          ;;
6204 <        -lkernel32)
6205 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6206 <          ;;
6207 <        -[LRuYz])
6208 <          # These flags, when seen by themselves, take an argument.
6209 <          # We remove the space between option and argument and re-iterate
6210 <          # unless we find an empty arg or a new option (starting with -)
6211 <          case $2 in
6212 <             "" | -*);;
6213 <             *)
6214 <                ac_arg="$ac_arg$2"
6215 <                shift; shift
6216 <                set X $ac_arg "$@"
6217 <                ;;
6218 <          esac
6219 <          ;;
6220 <        -YP,*)
6221 <          for ac_j in `$as_echo "$ac_arg" | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
6222 <              ac_exists=false
6223 <  for ac_i in $ac_cv_fc_libs; do
6224 <    if test x"$ac_j" = x"$ac_i"; then
6225 <      ac_exists=true
6226 <      break
6227 <    fi
6228 <  done
6229 <
6230 <  if test x"$ac_exists" = xtrue; then
6231 <  :
6232 < else
6233 <  ac_arg="$ac_arg $ac_j"
6234 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
6235 < fi
6236 <
6237 <          done
6238 <          ;;
6239 <        -[lLR]*)
6240 <            ac_exists=false
6241 <  for ac_i in $ac_cv_fc_libs; do
6242 <    if test x"$ac_arg" = x"$ac_i"; then
6243 <      ac_exists=true
6244 <      break
6245 <    fi
6246 <  done
6247 <
6248 <  if test x"$ac_exists" = xtrue; then
6249 <  :
6250 < else
6251 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6252 < fi
6253 <
6254 <          ;;
6255 <        -zallextract*| -zdefaultextract)
6256 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6257 <          ;;
6258 <          # Ignore everything else.
6259 <  esac
6260 < done
6261 < # restore positional arguments
6262 < set X $ac_save_positional; shift
6263 <
6264 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
6265 < # then we insist that the "run path" must be an absolute path (i.e. it
6266 < # must begin with a "/").
6267 < case `(uname -sr) 2>/dev/null` in
6268 <   "SunOS 5"*)
6269 <      ac_ld_run_path=`$as_echo "$ac_fc_v_output" |
6270 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
6271 <      test "x$ac_ld_run_path" != x &&
6272 <        if test "$ac_compiler_gnu" = yes; then
6273 <  for ac_link_opt in $ac_ld_run_path; do
6274 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6275 <  done
6276 < else
6277 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
6278 < fi
6279 <      ;;
6280 < esac
6281 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
6282 <
6283 < fi
6284 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
6285 < $as_echo "$ac_cv_fc_libs" >&6; }
6286 < FCLIBS="$ac_cv_fc_libs"
6287 <
6288 <
6289 < ac_ext=${ac_fc_srcext-f}
6290 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6291 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6292 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6293 <
6294 <
6295 < ac_ext=${ac_fc_srcext-f}
6296 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6297 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6298 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6299 <
6300 < { $as_echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
6301 < $as_echo_n "checking for dummy main to link with Fortran libraries... " >&6; }
6302 < if test "${ac_cv_fc_dummy_main+set}" = set; then
6303 <  $as_echo_n "(cached) " >&6
6304 < else
6305 <  ac_fc_dm_save_LIBS=$LIBS
6306 < LIBS="$LIBS $FCLIBS"
6307 < ac_fortran_dm_var=FC_DUMMY_MAIN
6308 < ac_ext=c
6309 < ac_cpp='$CPP $CPPFLAGS'
6310 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6311 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6312 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6313 <
6314 < # First, try linking without a dummy main:
6315 < cat >conftest.$ac_ext <<_ACEOF
6316 < /* confdefs.h.  */
6317 < _ACEOF
6318 < cat confdefs.h >>conftest.$ac_ext
6319 < cat >>conftest.$ac_ext <<_ACEOF
6320 < /* end confdefs.h.  */
6321 <
6322 < #ifdef FC_DUMMY_MAIN
6323 < #ifndef FC_DUMMY_MAIN_EQ_F77
6324 < #  ifdef __cplusplus
6325 <     extern "C"
6326 < #  endif
6327 <   int FC_DUMMY_MAIN() { return 1; }
6328 < #endif
6329 < #endif
6330 < int
6331 < main ()
6332 < {
6333 <
6334 <  ;
6335 <  return 0;
6336 < }
6337 < _ACEOF
6338 < rm -f conftest.$ac_objext conftest$ac_exeext
6339 < if { (ac_try="$ac_link"
6340 < case "(($ac_try" in
6341 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6342 <  *) ac_try_echo=$ac_try;;
6343 < esac
6344 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6345 < $as_echo "$ac_try_echo") >&5
6346 <  (eval "$ac_link") 2>conftest.er1
6347 <  ac_status=$?
6348 <  grep -v '^ *+' conftest.er1 >conftest.err
6349 <  rm -f conftest.er1
6350 <  cat conftest.err >&5
6351 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6352 <  (exit $ac_status); } && {
6353 <         test -z "$ac_c_werror_flag" ||
6354 <         test ! -s conftest.err
6355 <       } && test -s conftest$ac_exeext && {
6356 <         test "$cross_compiling" = yes ||
6357 <         $as_test_x conftest$ac_exeext
6358 <       }; then
6359 <  ac_cv_fortran_dummy_main=none
6360 < else
6361 <  $as_echo "$as_me: failed program was:" >&5
6362 < sed 's/^/| /' conftest.$ac_ext >&5
6363 <
6364 <        ac_cv_fortran_dummy_main=unknown
6365 < fi
6366 <
6367 < rm -rf conftest.dSYM
6368 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6369 <      conftest$ac_exeext conftest.$ac_ext
6370 <
6371 < if test $ac_cv_fortran_dummy_main = unknown; then
6372 <   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
6373 <     cat >conftest.$ac_ext <<_ACEOF
6374 < /* confdefs.h.  */
6375 < _ACEOF
6376 < cat confdefs.h >>conftest.$ac_ext
6377 < cat >>conftest.$ac_ext <<_ACEOF
6378 < /* end confdefs.h.  */
6379 < #define $ac_fortran_dm_var $ac_func
6380 < #ifdef FC_DUMMY_MAIN
6381 < #ifndef FC_DUMMY_MAIN_EQ_F77
6382 < #  ifdef __cplusplus
6383 <     extern "C"
6384 < #  endif
6385 <   int FC_DUMMY_MAIN() { return 1; }
6386 < #endif
6387 < #endif
6388 < int
6389 < main ()
6390 < {
6391 <
6392 <  ;
6393 <  return 0;
6394 < }
6395 < _ACEOF
6396 < rm -f conftest.$ac_objext conftest$ac_exeext
6397 < if { (ac_try="$ac_link"
6398 < case "(($ac_try" in
6399 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6400 <  *) ac_try_echo=$ac_try;;
6401 < esac
6402 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6403 < $as_echo "$ac_try_echo") >&5
6404 <  (eval "$ac_link") 2>conftest.er1
6405 <  ac_status=$?
6406 <  grep -v '^ *+' conftest.er1 >conftest.err
6407 <  rm -f conftest.er1
6408 <  cat conftest.err >&5
6409 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6410 <  (exit $ac_status); } && {
6411 <         test -z "$ac_c_werror_flag" ||
6412 <         test ! -s conftest.err
6413 <       } && test -s conftest$ac_exeext && {
6414 <         test "$cross_compiling" = yes ||
6415 <         $as_test_x conftest$ac_exeext
6416 <       }; then
6417 <  ac_cv_fortran_dummy_main=$ac_func; break
6418 < else
6419 <  $as_echo "$as_me: failed program was:" >&5
6420 < sed 's/^/| /' conftest.$ac_ext >&5
6421 <
6422 <
6423 < fi
6424 <
6425 < rm -rf conftest.dSYM
6426 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6427 <      conftest$ac_exeext conftest.$ac_ext
6428 <   done
6429 < fi
6430 < ac_ext=${ac_fc_srcext-f}
6431 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6432 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6433 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6434 < ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
6435 < rm -rf conftest*
6436 < LIBS=$ac_fc_dm_save_LIBS
6437 <
6438 < fi
6439 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
6440 < $as_echo "$ac_cv_fc_dummy_main" >&6; }
6441 < FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
6442 < if test "$FC_DUMMY_MAIN" != unknown; then
6443 <  if test $FC_DUMMY_MAIN != none; then
6444 <
6445 < cat >>confdefs.h <<_ACEOF
6446 < #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
6447 < _ACEOF
6448 <
6449 <  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
6450 <
6451 < cat >>confdefs.h <<\_ACEOF
6452 < #define FC_DUMMY_MAIN_EQ_F77 1
6453 < _ACEOF
6454 <
6455 <  fi
6456 < fi
6457 < else
6458 <  { { $as_echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
6459 < See \`config.log' for more details." >&5
6460 < $as_echo "$as_me: error: linking to Fortran libraries from C fails
6461 < See \`config.log' for more details." >&2;}
6462 <   { (exit 1); exit 1; }; }
6463 < fi
6464 <
6465 <
6466 < ac_ext=${ac_fc_srcext-f}
6467 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6468 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6469 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6470 <
6471 < ac_ext=${ac_fc_srcext-f}
6472 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6473 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6474 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6475 < { $as_echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
6476 < $as_echo_n "checking for Fortran name-mangling scheme... " >&6; }
6477 < if test "${ac_cv_fc_mangling+set}" = set; then
6478 <  $as_echo_n "(cached) " >&6
6479 < else
6480 <  cat >conftest.$ac_ext <<_ACEOF
6481 <      subroutine foobar()
6482 <      return
6483 <      end
6484 <      subroutine foo_bar()
6485 <      return
6486 <      end
6487 < _ACEOF
6488 < rm -f conftest.$ac_objext
6489 < if { (ac_try="$ac_compile"
6490 < case "(($ac_try" in
6491 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6492 <  *) ac_try_echo=$ac_try;;
6493 < esac
6494 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6495 < $as_echo "$ac_try_echo") >&5
6496 <  (eval "$ac_compile") 2>conftest.er1
6497 <  ac_status=$?
6498 <  grep -v '^ *+' conftest.er1 >conftest.err
6499 <  rm -f conftest.er1
6500 <  cat conftest.err >&5
6501 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6502 <  (exit $ac_status); } && {
6503 <         test -z "$ac_fc_werror_flag" ||
6504 <         test ! -s conftest.err
6505 <       } && test -s conftest.$ac_objext; then
6506 <  mv conftest.$ac_objext cfortran_test.$ac_objext
6507 <
6508 <  ac_save_LIBS=$LIBS
6509 <  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
6510 <
6511 <  ac_ext=c
6512 < ac_cpp='$CPP $CPPFLAGS'
6513 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6514 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6515 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6516 <  ac_success=no
6517 <  for ac_foobar in foobar FOOBAR; do
6518 <    for ac_underscore in "" "_"; do
6519 <      ac_func="$ac_foobar$ac_underscore"
6520 <      cat >conftest.$ac_ext <<_ACEOF
6521 < /* confdefs.h.  */
6522 < _ACEOF
6523 < cat confdefs.h >>conftest.$ac_ext
6524 < cat >>conftest.$ac_ext <<_ACEOF
6525 < /* end confdefs.h.  */
6526 <
6527 < /* Override any GCC internal prototype to avoid an error.
6528 <   Use char because int might match the return type of a GCC
6529 <   builtin and then its argument prototype would still apply.  */
6530 < #ifdef __cplusplus
6531 < extern "C"
6532 < #endif
6533 < char $ac_func ();
6534 < #ifdef FC_DUMMY_MAIN
6535 < #ifndef FC_DUMMY_MAIN_EQ_F77
6536 < #  ifdef __cplusplus
6537 <     extern "C"
6538 < #  endif
6539 <   int FC_DUMMY_MAIN() { return 1; }
6540 < #endif
6541 < #endif
6542 < int
6543 < main ()
6544 < {
6545 < return $ac_func ();
6546 <  ;
6547 <  return 0;
6548 < }
6549 < _ACEOF
6550 < rm -f conftest.$ac_objext conftest$ac_exeext
6551 < if { (ac_try="$ac_link"
6552 < case "(($ac_try" in
6553 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6554 <  *) ac_try_echo=$ac_try;;
6555 < esac
6556 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6557 < $as_echo "$ac_try_echo") >&5
6558 <  (eval "$ac_link") 2>conftest.er1
6559 <  ac_status=$?
6560 <  grep -v '^ *+' conftest.er1 >conftest.err
6561 <  rm -f conftest.er1
6562 <  cat conftest.err >&5
6563 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6564 <  (exit $ac_status); } && {
6565 <         test -z "$ac_c_werror_flag" ||
6566 <         test ! -s conftest.err
6567 <       } && test -s conftest$ac_exeext && {
6568 <         test "$cross_compiling" = yes ||
6569 <         $as_test_x conftest$ac_exeext
6570 <       }; then
6571 <  ac_success=yes; break 2
6572 < else
6573 <  $as_echo "$as_me: failed program was:" >&5
6574 < sed 's/^/| /' conftest.$ac_ext >&5
6575 <
6576 <
6577 < fi
6578 <
6579 < rm -rf conftest.dSYM
6580 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6581 <      conftest$ac_exeext conftest.$ac_ext
6582 <    done
6583 <  done
6584 <  ac_ext=${ac_fc_srcext-f}
6585 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6586 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6587 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6588 <
6589 <  if test "$ac_success" = "yes"; then
6590 <     case $ac_foobar in
6591 <        foobar)
6592 <           ac_case=lower
6593 <           ac_foo_bar=foo_bar
6594 <           ;;
6595 <        FOOBAR)
6596 <           ac_case=upper
6597 <           ac_foo_bar=FOO_BAR
6598 <           ;;
6599 <     esac
6600 <
6601 <     ac_ext=c
6602 < ac_cpp='$CPP $CPPFLAGS'
6603 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6604 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6605 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6606 <     ac_success_extra=no
6607 <     for ac_extra in "" "_"; do
6608 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
6609 <        cat >conftest.$ac_ext <<_ACEOF
6610 < /* confdefs.h.  */
6611 < _ACEOF
6612 < cat confdefs.h >>conftest.$ac_ext
6613 < cat >>conftest.$ac_ext <<_ACEOF
6614 < /* end confdefs.h.  */
6615 <
6616 < /* Override any GCC internal prototype to avoid an error.
6617 <   Use char because int might match the return type of a GCC
6618 <   builtin and then its argument prototype would still apply.  */
6619 < #ifdef __cplusplus
6620 < extern "C"
6621 < #endif
6622 < char $ac_func ();
6623 < #ifdef FC_DUMMY_MAIN
6624 < #ifndef FC_DUMMY_MAIN_EQ_F77
6625 < #  ifdef __cplusplus
6626 <     extern "C"
6627 < #  endif
6628 <   int FC_DUMMY_MAIN() { return 1; }
6629 < #endif
6630 < #endif
6631 < int
6632 < main ()
6633 < {
6634 < return $ac_func ();
6635 <  ;
6636 <  return 0;
6637 < }
6638 < _ACEOF
6639 < rm -f conftest.$ac_objext conftest$ac_exeext
6640 < if { (ac_try="$ac_link"
6641 < case "(($ac_try" in
6642 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6643 <  *) ac_try_echo=$ac_try;;
6644 < esac
6645 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6646 < $as_echo "$ac_try_echo") >&5
6647 <  (eval "$ac_link") 2>conftest.er1
6648 <  ac_status=$?
6649 <  grep -v '^ *+' conftest.er1 >conftest.err
6650 <  rm -f conftest.er1
6651 <  cat conftest.err >&5
6652 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6653 <  (exit $ac_status); } && {
6654 <         test -z "$ac_c_werror_flag" ||
6655 <         test ! -s conftest.err
6656 <       } && test -s conftest$ac_exeext && {
6657 <         test "$cross_compiling" = yes ||
6658 <         $as_test_x conftest$ac_exeext
6659 <       }; then
6660 <  ac_success_extra=yes; break
6661 < else
6662 <  $as_echo "$as_me: failed program was:" >&5
6663 < sed 's/^/| /' conftest.$ac_ext >&5
6664 <
6665 <
6666 < fi
6667 <
6668 < rm -rf conftest.dSYM
6669 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6670 <      conftest$ac_exeext conftest.$ac_ext
6671 <     done
6672 <     ac_ext=${ac_fc_srcext-f}
6673 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6674 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6675 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6676 <
6677 <     if test "$ac_success_extra" = "yes"; then
6678 <        ac_cv_fc_mangling="$ac_case case"
6679 <        if test -z "$ac_underscore"; then
6680 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
6681 <        else
6682 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
6683 <        fi
6684 <        if test -z "$ac_extra"; then
6685 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
6686 <        else
6687 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
6688 <        fi
6689 <      else
6690 <        ac_cv_fc_mangling="unknown"
6691 <      fi
6692 <  else
6693 <     ac_cv_fc_mangling="unknown"
6694 <  fi
6695 <
6696 <  LIBS=$ac_save_LIBS
6697 <  rm -rf conftest*
6698 <  rm -f cfortran_test*
6699 < else
6700 <  $as_echo "$as_me: failed program was:" >&5
6701 < sed 's/^/| /' conftest.$ac_ext >&5
6702 <
6703 <        { { $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; }; }
6708 < fi
6709 <
6710 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6711 <
6712 < fi
6713 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
6714 < $as_echo "$ac_cv_fc_mangling" >&6; }
6715 <
6716 < ac_ext=${ac_fc_srcext-f}
6717 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6718 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6719 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6720 <
6721 < ac_ext=${ac_fc_srcext-f}
6722 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6723 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6724 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6725 <
6726 <
6727 < case $ac_cv_fc_mangling in
6728 <  "lower case, no underscore, no extra underscore")
6729 <          cat >>confdefs.h <<\_ACEOF
6730 < #define FC_FUNC(name,NAME) name
6731 < _ACEOF
6732 <
6733 <          cat >>confdefs.h <<\_ACEOF
6734 < #define FC_FUNC_(name,NAME) name
6735 < _ACEOF
6736 < ;;
6737 <  "lower case, no underscore, extra underscore")
6738 <          cat >>confdefs.h <<\_ACEOF
6739 < #define FC_FUNC(name,NAME) name
6740 < _ACEOF
6741 <
6742 <          cat >>confdefs.h <<\_ACEOF
6743 < #define FC_FUNC_(name,NAME) name ## _
6744 < _ACEOF
6745 < ;;
6746 <  "lower case, underscore, no extra underscore")
6747 <          cat >>confdefs.h <<\_ACEOF
6748 < #define FC_FUNC(name,NAME) name ## _
6749 < _ACEOF
6750 <
6751 <          cat >>confdefs.h <<\_ACEOF
6752 < #define FC_FUNC_(name,NAME) name ## _
6753 < _ACEOF
6754 < ;;
6755 <  "lower case, underscore, extra underscore")
6756 <          cat >>confdefs.h <<\_ACEOF
6757 < #define FC_FUNC(name,NAME) name ## _
6758 < _ACEOF
6759 <
6760 <          cat >>confdefs.h <<\_ACEOF
6761 < #define FC_FUNC_(name,NAME) name ## __
6762 < _ACEOF
6763 < ;;
6764 <  "upper case, no underscore, no extra underscore")
6765 <          cat >>confdefs.h <<\_ACEOF
6766 < #define FC_FUNC(name,NAME) NAME
6767 < _ACEOF
6768 <
6769 <          cat >>confdefs.h <<\_ACEOF
6770 < #define FC_FUNC_(name,NAME) NAME
6771 < _ACEOF
6772 < ;;
6773 <  "upper case, no underscore, extra underscore")
6774 <          cat >>confdefs.h <<\_ACEOF
6775 < #define FC_FUNC(name,NAME) NAME
6776 < _ACEOF
6777 <
6778 <          cat >>confdefs.h <<\_ACEOF
6779 < #define FC_FUNC_(name,NAME) NAME ## _
6780 < _ACEOF
6781 < ;;
6782 <  "upper case, underscore, no extra underscore")
6783 <          cat >>confdefs.h <<\_ACEOF
6784 < #define FC_FUNC(name,NAME) NAME ## _
6785 < _ACEOF
6786 <
6787 <          cat >>confdefs.h <<\_ACEOF
6788 < #define FC_FUNC_(name,NAME) NAME ## _
6789 < _ACEOF
6790 < ;;
6791 <  "upper case, underscore, extra underscore")
6792 <          cat >>confdefs.h <<\_ACEOF
6793 < #define FC_FUNC(name,NAME) NAME ## _
6794 < _ACEOF
6795 <
6796 <          cat >>confdefs.h <<\_ACEOF
6797 < #define FC_FUNC_(name,NAME) NAME ## __
6798 < _ACEOF
6799 < ;;
6800 <  *)
6801 <          { $as_echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
6802 < $as_echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
6803 <          ;;
6804 < esac
6805 <
6806 < ac_ext=${ac_fc_srcext-f}
6807 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6808 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6809 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6810 <
6811 <
6812 <
6813 < ac_ext=${ac_fc_srcext-f}
6814 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6815 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6816 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6817 < { $as_echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
6818 < $as_echo_n "checking how to get verbose linking output from $FC... " >&6; }
6819 < if test "${ac_cv_prog_fc_v+set}" = set; then
6820 <  $as_echo_n "(cached) " >&6
6821 < else
6822 <  cat >conftest.$ac_ext <<_ACEOF
6823 <      program main
6824 <
6825 <      end
6826 < _ACEOF
6827 < 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
6845 <  ac_cv_prog_fc_v=
6846 < # Try some options frequently used verbose output
6847 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
6848 <  cat >conftest.$ac_ext <<_ACEOF
6849 <      program main
6850 <
6851 <      end
6852 < _ACEOF
6853 <
6854 < # Compile and link our simple test program by passing a flag (argument
6855 < # 1 to this macro) to the Fortran compiler in order to get
6856 < # "verbose" output that we can then parse for the Fortran linker
6857 < # flags.
6858 < ac_save_FFLAGS=$FCFLAGS
6859 < FCFLAGS="$FCFLAGS $ac_verb"
6860 < eval "set x $ac_link"
6861 < shift
6862 < $as_echo "$as_me:$LINENO: $*" >&5
6863 < # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
6864 < # LIBRARY_PATH; skip all such settings.
6865 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
6866 <  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
6867 < $as_echo "$ac_fc_v_output" >&5
6868 < FCFLAGS=$ac_save_FFLAGS
6869 <
6870 < rm -rf conftest*
6871 <
6872 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6873 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6874 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6875 < ac_fc_v_output="`echo $ac_fc_v_output |
6876 <        grep 'LPATH is:' |
6877 <        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
6878 <
6879 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6880 < #        that detects unbalanced quotes in FLIBS should be implemented
6881 < #        and (ugh) tested at some point.
6882 < case $ac_fc_v_output in
6883 <  # If we are using xlf then replace all the commas with spaces.
6884 <  *xlfentry*)
6885 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6886 <
6887 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6888 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6889 <  *mGLOB_options_string*)
6890 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6891 <
6892 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6893 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6894 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6895 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6896 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6897 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6898 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6899 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6900 <
6901 <  # If we are using Cray Fortran then delete quotes.
6902 <  *cft90*)
6903 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6904 < esac
6905 <
6906 <
6907 <  # look for -l* and *.a constructs in the output
6908 <  for ac_arg in $ac_fc_v_output; do
6909 <     case $ac_arg in
6910 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
6911 <          ac_cv_prog_fc_v=$ac_verb
6912 <          break 2 ;;
6913 <     esac
6914 <  done
6915 < done
6916 < if test -z "$ac_cv_prog_fc_v"; then
6917 <   { $as_echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
6918 < $as_echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
6919 < fi
6920 < else
6921 <  $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
6925 < $as_echo "$as_me: WARNING: compilation failed" >&2;}
6926 < fi
6927 <
6928 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6929 <
6930 < fi
6931 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
6932 < $as_echo "$ac_cv_prog_fc_v" >&6; }
6933 < { $as_echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
6934 < $as_echo_n "checking for Fortran libraries of $FC... " >&6; }
6935 < if test "${ac_cv_fc_libs+set}" = set; then
6936 <  $as_echo_n "(cached) " >&6
6937 < else
6938 <  if test "x$FCLIBS" != "x"; then
6939 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
6940 < else
6941 <
6942 < cat >conftest.$ac_ext <<_ACEOF
6943 <      program main
6944 <
6945 <      end
6946 < _ACEOF
6947 <
6948 < # Compile and link our simple test program by passing a flag (argument
6949 < # 1 to this macro) to the Fortran compiler in order to get
6950 < # "verbose" output that we can then parse for the Fortran linker
6951 < # flags.
6952 < ac_save_FFLAGS=$FCFLAGS
6953 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
6954 < eval "set x $ac_link"
6955 < shift
6956 < $as_echo "$as_me:$LINENO: $*" >&5
6957 < # gfortran 4.3 outputs lines setting COLLECT_GCC_OPTIONS, COMPILER_PATH,
6958 < # LIBRARY_PATH; skip all such settings.
6959 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 |
6960 <  grep -v 'Driving:' | grep -v "^[_$as_cr_Letters][_$as_cr_alnum]*="`
6961 < $as_echo "$ac_fc_v_output" >&5
6962 < FCFLAGS=$ac_save_FFLAGS
6963 <
6964 < rm -rf conftest*
6965 <
6966 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6967 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6968 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6969 < ac_fc_v_output="`echo $ac_fc_v_output |
6970 <        grep 'LPATH is:' |
6971 <        sed 's|.*LPATH is\(: *[^ ]*\).*|\1|;s|: */| -L/|g'` $ac_fc_v_output"
6972 <
6973 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6974 < #        that detects unbalanced quotes in FLIBS should be implemented
6975 < #        and (ugh) tested at some point.
6976 < case $ac_fc_v_output in
6977 <  # If we are using xlf then replace all the commas with spaces.
6978 <  *xlfentry*)
6979 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6980 <
6981 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6982 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6983 <  *mGLOB_options_string*)
6984 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6985 <
6986 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6987 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6988 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6989 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6990 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6991 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6992 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6993 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6994 <
6995 <  # If we are using Cray Fortran then delete quotes.
6996 <  *cft90*)
6997 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6998 < esac
6999 <
7000 <
7001 <
7002 < ac_cv_fc_libs=
7003 <
7004 < # Save positional arguments (if any)
7005 < ac_save_positional="$@"
7006 <
7007 < set X $ac_fc_v_output
7008 < while test $# != 1; do
7009 <  shift
7010 <  ac_arg=$1
7011 <  case $ac_arg in
7012 <        [\\/]*.a | ?:[\\/]*.a)
7013 <            ac_exists=false
7014 <  for ac_i in $ac_cv_fc_libs; do
7015 <    if test x"$ac_arg" = x"$ac_i"; then
7016 <      ac_exists=true
7017 <      break
7018 <    fi
7019 <  done
7020 <
7021 <  if test x"$ac_exists" = xtrue; then
7022 <  :
7023 < else
7024 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7025 < fi
7026 <
7027 <          ;;
7028 <        -bI:*)
7029 <            ac_exists=false
7030 <  for ac_i in $ac_cv_fc_libs; do
7031 <    if test x"$ac_arg" = x"$ac_i"; then
7032 <      ac_exists=true
7033 <      break
7034 <    fi
7035 <  done
7036 <
7037 <  if test x"$ac_exists" = xtrue; then
7038 <  :
7039 < else
7040 <  if test "$ac_compiler_gnu" = yes; then
7041 <  for ac_link_opt in $ac_arg; do
7042 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
7043 <  done
7044 < else
7045 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7046 < fi
7047 < fi
7048 <
7049 <          ;;
7050 <          # Ignore these flags.
7051 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
7052 <          ;;
7053 <        -lkernel32)
7054 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7055 <          ;;
7056 <        -[LRuYz])
7057 <          # These flags, when seen by themselves, take an argument.
7058 <          # We remove the space between option and argument and re-iterate
7059 <          # unless we find an empty arg or a new option (starting with -)
7060 <          case $2 in
7061 <             "" | -*);;
7062 <             *)
7063 <                ac_arg="$ac_arg$2"
7064 <                shift; shift
7065 <                set X $ac_arg "$@"
7066 <                ;;
7067 <          esac
7068 <          ;;
7069 <        -YP,*)
7070 <          for ac_j in `$as_echo "$ac_arg" | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
7071 <              ac_exists=false
7072 <  for ac_i in $ac_cv_fc_libs; do
7073 <    if test x"$ac_j" = x"$ac_i"; then
7074 <      ac_exists=true
7075 <      break
7076 <    fi
7077 <  done
7078 <
7079 <  if test x"$ac_exists" = xtrue; then
7080 <  :
7081 < else
7082 <  ac_arg="$ac_arg $ac_j"
7083 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
7084 < fi
7085 <
7086 <          done
7087 <          ;;
7088 <        -[lLR]*)
7089 <            ac_exists=false
7090 <  for ac_i in $ac_cv_fc_libs; do
7091 <    if test x"$ac_arg" = x"$ac_i"; then
7092 <      ac_exists=true
7093 <      break
7094 <    fi
7095 <  done
7096 <
7097 <  if test x"$ac_exists" = xtrue; then
7098 <  :
7099 < else
7100 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7101 < fi
7102 <
7103 <          ;;
7104 <        -zallextract*| -zdefaultextract)
7105 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
7106 <          ;;
7107 <          # Ignore everything else.
7108 <  esac
7109 < done
7110 < # restore positional arguments
7111 < set X $ac_save_positional; shift
7112 <
7113 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
7114 < # then we insist that the "run path" must be an absolute path (i.e. it
7115 < # must begin with a "/").
7116 < case `(uname -sr) 2>/dev/null` in
7117 <   "SunOS 5"*)
7118 <      ac_ld_run_path=`$as_echo "$ac_fc_v_output" |
7119 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
7120 <      test "x$ac_ld_run_path" != x &&
7121 <        if test "$ac_compiler_gnu" = yes; then
7122 <  for ac_link_opt in $ac_ld_run_path; do
7123 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
7124 <  done
7125 < else
7126 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
7127 < fi
7128 <      ;;
7129 < esac
7130 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
7131 <
7132 < fi
7133 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
7134 < $as_echo "$ac_cv_fc_libs" >&6; }
7135 < FCLIBS="$ac_cv_fc_libs"
7136 <
7137 <
7138 < ac_ext=${ac_fc_srcext-f}
7139 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7140 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7141 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4236 > else
4237 >
4238 >        CXX=$save_CXX
4239 >        CC=$save_CC
4240 >        LIBS=$save_LIBS
4241 >
4242 >
4243 > fi
4244 >
4245 >
4246 > # Checks for programs.
4247 > ac_ext=c
4248 > ac_cpp='$CPP $CPPFLAGS'
4249 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4250 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4251 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4252 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
4253 > $as_echo_n "checking how to run the C preprocessor... " >&6; }
4254 > # On Suns, sometimes $CPP names a directory.
4255 > if test -n "$CPP" && test -d "$CPP"; then
4256 >  CPP=
4257 > fi
4258 > if test -z "$CPP"; then
4259 >  if ${ac_cv_prog_CPP+:} false; then :
4260 >  $as_echo_n "(cached) " >&6
4261 > else
4262 >      # Double quotes because CPP needs to be expanded
4263 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4264 >    do
4265 >      ac_preproc_ok=false
4266 > for ac_c_preproc_warn_flag in '' yes
4267 > do
4268 >  # Use a header file that comes with gcc, so configuring glibc
4269 >  # with a fresh cross-compiler works.
4270 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4271 >  # <limits.h> exists even on freestanding compilers.
4272 >  # On the NeXT, cc -E runs the code through the compiler's parser,
4273 >  # not just through cpp. "Syntax error" is here to catch this case.
4274 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4275 > /* end confdefs.h.  */
4276 > #ifdef __STDC__
4277 > # include <limits.h>
4278 > #else
4279 > # include <assert.h>
4280 > #endif
4281 >                     Syntax error
4282 > _ACEOF
4283 > if ac_fn_c_try_cpp "$LINENO"; then :
4284 >
4285 > else
4286 >  # Broken: fails on valid input.
4287 > continue
4288 > fi
4289 > rm -f conftest.err conftest.i conftest.$ac_ext
4290 >
4291 >  # OK, works on sane cases.  Now check whether nonexistent headers
4292 >  # can be detected and how.
4293 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4294 > /* end confdefs.h.  */
4295 > #include <ac_nonexistent.h>
4296 > _ACEOF
4297 > if ac_fn_c_try_cpp "$LINENO"; then :
4298 >  # Broken: success on invalid input.
4299 > continue
4300 > else
4301 >  # Passes both tests.
4302 > ac_preproc_ok=:
4303 > break
4304 > fi
4305 > rm -f conftest.err conftest.i conftest.$ac_ext
4306 >
4307 > done
4308 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4309 > rm -f conftest.i conftest.err conftest.$ac_ext
4310 > if $ac_preproc_ok; then :
4311 >  break
4312 > fi
4313 >
4314 >    done
4315 >    ac_cv_prog_CPP=$CPP
4316 >
4317 > fi
4318 >  CPP=$ac_cv_prog_CPP
4319 > else
4320 >  ac_cv_prog_CPP=$CPP
4321 > fi
4322 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
4323 > $as_echo "$CPP" >&6; }
4324 > ac_preproc_ok=false
4325 > for ac_c_preproc_warn_flag in '' yes
4326 > do
4327 >  # Use a header file that comes with gcc, so configuring glibc
4328 >  # with a fresh cross-compiler works.
4329 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4330 >  # <limits.h> exists even on freestanding compilers.
4331 >  # On the NeXT, cc -E runs the code through the compiler's parser,
4332 >  # not just through cpp. "Syntax error" is here to catch this case.
4333 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4334 > /* end confdefs.h.  */
4335 > #ifdef __STDC__
4336 > # include <limits.h>
4337 > #else
4338 > # include <assert.h>
4339 > #endif
4340 >                     Syntax error
4341 > _ACEOF
4342 > if ac_fn_c_try_cpp "$LINENO"; then :
4343 >
4344 > else
4345 >  # Broken: fails on valid input.
4346 > continue
4347 > fi
4348 > rm -f conftest.err conftest.i conftest.$ac_ext
4349 >
4350 >  # OK, works on sane cases.  Now check whether nonexistent headers
4351 >  # can be detected and how.
4352 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4353 > /* end confdefs.h.  */
4354 > #include <ac_nonexistent.h>
4355 > _ACEOF
4356 > if ac_fn_c_try_cpp "$LINENO"; then :
4357 >  # Broken: success on invalid input.
4358 > continue
4359 > else
4360 >  # Passes both tests.
4361 > ac_preproc_ok=:
4362 > break
4363 > fi
4364 > rm -f conftest.err conftest.i conftest.$ac_ext
4365 >
4366 > done
4367 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4368 > rm -f conftest.i conftest.err conftest.$ac_ext
4369 > if $ac_preproc_ok; then :
4370 >
4371 > else
4372 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4373 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4374 > as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
4375 > See \`config.log' for more details" "$LINENO" 5; }
4376 > fi
4377 >
4378 > ac_ext=c
4379 > ac_cpp='$CPP $CPPFLAGS'
4380 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4381 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4382 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4383 >
4384 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
4385 > $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
4386 > if ${ac_cv_path_GREP+:} false; then :
4387 >  $as_echo_n "(cached) " >&6
4388 > else
4389 >  if test -z "$GREP"; then
4390 >  ac_path_GREP_found=false
4391 >  # Loop through the user's path and test for each of PROGNAME-LIST
4392 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4393 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4394 > do
4395 >  IFS=$as_save_IFS
4396 >  test -z "$as_dir" && as_dir=.
4397 >    for ac_prog in grep ggrep; do
4398 >    for ac_exec_ext in '' $ac_executable_extensions; do
4399 >      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4400 >      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4401 > # Check for GNU ac_path_GREP and select it if it is found.
4402 >  # Check for GNU $ac_path_GREP
4403 > case `"$ac_path_GREP" --version 2>&1` in
4404 > *GNU*)
4405 >  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4406 > *)
4407 >  ac_count=0
4408 >  $as_echo_n 0123456789 >"conftest.in"
4409 >  while :
4410 >  do
4411 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
4412 >    mv "conftest.tmp" "conftest.in"
4413 >    cp "conftest.in" "conftest.nl"
4414 >    $as_echo 'GREP' >> "conftest.nl"
4415 >    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4416 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4417 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4418 >    if test $ac_count -gt ${ac_path_GREP_max-0}; then
4419 >      # Best one so far, save it but keep looking for a better one
4420 >      ac_cv_path_GREP="$ac_path_GREP"
4421 >      ac_path_GREP_max=$ac_count
4422 >    fi
4423 >    # 10*(2^10) chars as input seems more than enough
4424 >    test $ac_count -gt 10 && break
4425 >  done
4426 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4427 > esac
4428 >
4429 >      $ac_path_GREP_found && break 3
4430 >    done
4431 >  done
4432 >  done
4433 > IFS=$as_save_IFS
4434 >  if test -z "$ac_cv_path_GREP"; then
4435 >    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4436 >  fi
4437 > else
4438 >  ac_cv_path_GREP=$GREP
4439 > fi
4440 >
4441 > fi
4442 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
4443 > $as_echo "$ac_cv_path_GREP" >&6; }
4444 > GREP="$ac_cv_path_GREP"
4445 >
4446 >
4447 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
4448 > $as_echo_n "checking for egrep... " >&6; }
4449 > if ${ac_cv_path_EGREP+:} false; then :
4450 >  $as_echo_n "(cached) " >&6
4451 > else
4452 >  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
4453 >   then ac_cv_path_EGREP="$GREP -E"
4454 >   else
4455 >     if test -z "$EGREP"; then
4456 >  ac_path_EGREP_found=false
4457 >  # Loop through the user's path and test for each of PROGNAME-LIST
4458 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4459 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4460 > do
4461 >  IFS=$as_save_IFS
4462 >  test -z "$as_dir" && as_dir=.
4463 >    for ac_prog in egrep; do
4464 >    for ac_exec_ext in '' $ac_executable_extensions; do
4465 >      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4466 >      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4467 > # Check for GNU ac_path_EGREP and select it if it is found.
4468 >  # Check for GNU $ac_path_EGREP
4469 > case `"$ac_path_EGREP" --version 2>&1` in
4470 > *GNU*)
4471 >  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
4472 > *)
4473 >  ac_count=0
4474 >  $as_echo_n 0123456789 >"conftest.in"
4475 >  while :
4476 >  do
4477 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
4478 >    mv "conftest.tmp" "conftest.in"
4479 >    cp "conftest.in" "conftest.nl"
4480 >    $as_echo 'EGREP' >> "conftest.nl"
4481 >    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4482 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4483 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4484 >    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
4485 >      # Best one so far, save it but keep looking for a better one
4486 >      ac_cv_path_EGREP="$ac_path_EGREP"
4487 >      ac_path_EGREP_max=$ac_count
4488 >    fi
4489 >    # 10*(2^10) chars as input seems more than enough
4490 >    test $ac_count -gt 10 && break
4491 >  done
4492 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4493 > esac
4494 >
4495 >      $ac_path_EGREP_found && break 3
4496 >    done
4497 >  done
4498 >  done
4499 > IFS=$as_save_IFS
4500 >  if test -z "$ac_cv_path_EGREP"; then
4501 >    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4502 >  fi
4503 > else
4504 >  ac_cv_path_EGREP=$EGREP
4505 > fi
4506 >
4507 >   fi
4508 > fi
4509 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
4510 > $as_echo "$ac_cv_path_EGREP" >&6; }
4511 > EGREP="$ac_cv_path_EGREP"
4512 >
4513 >
4514 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
4515 > $as_echo_n "checking whether ln -s works... " >&6; }
4516 > LN_S=$as_ln_s
4517 > if test "$LN_S" = "ln -s"; then
4518 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4519 > $as_echo "yes" >&6; }
4520 > else
4521 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
4522 > $as_echo "no, using $LN_S" >&6; }
4523 > fi
4524 >
4525 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4526 > $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
4527 > set x ${MAKE-make}
4528 > ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
4529 > if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
4530 >  $as_echo_n "(cached) " >&6
4531 > else
4532 >  cat >conftest.make <<\_ACEOF
4533 > SHELL = /bin/sh
4534 > all:
4535 >        @echo '@@@%%%=$(MAKE)=@@@%%%'
4536 > _ACEOF
4537 > # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
4538 > case `${MAKE-make} -f conftest.make 2>/dev/null` in
4539 >  *@@@%%%=?*=@@@%%%*)
4540 >    eval ac_cv_prog_make_${ac_make}_set=yes;;
4541 >  *)
4542 >    eval ac_cv_prog_make_${ac_make}_set=no;;
4543 > esac
4544 > rm -f conftest.make
4545 > fi
4546 > if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
4547 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4548 > $as_echo "yes" >&6; }
4549 >  SET_MAKE=
4550 > else
4551 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4552 > $as_echo "no" >&6; }
4553 >  SET_MAKE="MAKE=${MAKE-make}"
4554 > fi
4555 >
4556 > if test -n "$ac_tool_prefix"; then
4557 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4558 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4559 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4560 > $as_echo_n "checking for $ac_word... " >&6; }
4561 > if ${ac_cv_prog_RANLIB+:} false; then :
4562 >  $as_echo_n "(cached) " >&6
4563 > else
4564 >  if test -n "$RANLIB"; then
4565 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4566 > else
4567 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4568 > for as_dir in $PATH
4569 > do
4570 >  IFS=$as_save_IFS
4571 >  test -z "$as_dir" && as_dir=.
4572 >    for ac_exec_ext in '' $ac_executable_extensions; do
4573 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4574 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4575 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4576 >    break 2
4577 >  fi
4578 > done
4579 >  done
4580 > IFS=$as_save_IFS
4581 >
4582 > fi
4583 > fi
4584 > RANLIB=$ac_cv_prog_RANLIB
4585 > if test -n "$RANLIB"; then
4586 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
4587 > $as_echo "$RANLIB" >&6; }
4588 > else
4589 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4590 > $as_echo "no" >&6; }
4591 > fi
4592 >
4593 >
4594 > fi
4595 > if test -z "$ac_cv_prog_RANLIB"; then
4596 >  ac_ct_RANLIB=$RANLIB
4597 >  # Extract the first word of "ranlib", so it can be a program name with args.
4598 > set dummy ranlib; ac_word=$2
4599 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4600 > $as_echo_n "checking for $ac_word... " >&6; }
4601 > if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
4602 >  $as_echo_n "(cached) " >&6
4603 > else
4604 >  if test -n "$ac_ct_RANLIB"; then
4605 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4606 > else
4607 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4608 > for as_dir in $PATH
4609 > do
4610 >  IFS=$as_save_IFS
4611 >  test -z "$as_dir" && as_dir=.
4612 >    for ac_exec_ext in '' $ac_executable_extensions; do
4613 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4614 >    ac_cv_prog_ac_ct_RANLIB="ranlib"
4615 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4616 >    break 2
4617 >  fi
4618 > done
4619 >  done
4620 > IFS=$as_save_IFS
4621 >
4622 > fi
4623 > fi
4624 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4625 > if test -n "$ac_ct_RANLIB"; then
4626 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
4627 > $as_echo "$ac_ct_RANLIB" >&6; }
4628 > else
4629 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4630 > $as_echo "no" >&6; }
4631 > fi
4632 >
4633 >  if test "x$ac_ct_RANLIB" = x; then
4634 >    RANLIB=":"
4635 >  else
4636 >    case $cross_compiling:$ac_tool_warned in
4637 > yes:)
4638 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4639 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4640 > ac_tool_warned=yes ;;
4641 > esac
4642 >    RANLIB=$ac_ct_RANLIB
4643 >  fi
4644 > else
4645 >  RANLIB="$ac_cv_prog_RANLIB"
4646 > fi
4647 >
4648 >
4649 >   # Extract the first word of "perl", so it can be a program name with args.
4650 > set dummy perl; ac_word=$2
4651 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4652 > $as_echo_n "checking for $ac_word... " >&6; }
4653 > if ${ac_cv_path_PERLINTERP+:} false; then :
4654 >  $as_echo_n "(cached) " >&6
4655 > else
4656 >  case $PERLINTERP in
4657 >  [\\/]* | ?:[\\/]*)
4658 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
4659 >  ;;
4660 >  *)
4661 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4662 > for as_dir in $PATH
4663 > do
4664 >  IFS=$as_save_IFS
4665 >  test -z "$as_dir" && as_dir=.
4666 >    for ac_exec_ext in '' $ac_executable_extensions; do
4667 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4668 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
4669 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4670 >    break 2
4671 >  fi
4672 > done
4673 >  done
4674 > IFS=$as_save_IFS
4675 >
4676 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
4677 >  ;;
4678 > esac
4679 > fi
4680 > PERLINTERP=$ac_cv_path_PERLINTERP
4681 > if test -n "$PERLINTERP"; then
4682 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERLINTERP" >&5
4683 > $as_echo "$PERLINTERP" >&6; }
4684 > else
4685 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4686 > $as_echo "no" >&6; }
4687 > fi
4688 >
4689 >
4690 >   ac_cv_path_perlinterp="$PERLINTERP"
4691 >   _sHpB='#!'
4692 >
4693 >
4694 > # Check whether --with-perl-shebang was given.
4695 > if test "${with_perl_shebang+set}" = set; then :
4696 >  withval=$with_perl_shebang; opt_perl_shebang="$withval"
4697 > else
4698 >                opt_perl_shebang="not_set"
4699 > fi
4700  
4701 +   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether explicit instead of detected sharpbang is to be used" >&5
4702 + $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
4703 + if ${ax_cv_opt_perl_shebang+:} false; then :
4704 +  $as_echo_n "(cached) " >&6
4705 + else
4706 +   case "$opt_perl_shebang" in
4707 +                      not_set  ) ax_cv_opt_perl_shebang=''
4708 +                               ;;
4709 +                         *     )
4710 +        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
4711 +                    esac
4712  
4713 + fi
4714 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_opt_perl_shebang" >&5
4715 + $as_echo "$ax_cv_opt_perl_shebang" >&6; }
4716 +   if test "A$ax_cv_opt_perl_shebang" != "A"
4717 +     then
4718 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
4719 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4720 +              { $as_echo "$as_me:${as_lineno-$LINENO}: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
4721 + $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
4722  
4723 < { $as_echo "$as_me:$LINENO: checking for module suffix" >&5
4724 < $as_echo_n "checking for module suffix... " >&6; }
4725 < rm -f conftest*
4726 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4727 < rm -f work*
4728 < cat >conftest.$ac_ext <<EOF
4729 <        module conftest
4730 <        integer n
7153 <        parameter (n=1)
7154 <        end module conftest
7155 < EOF
7156 < # SGI and absoft compilers generates module name in upper case!
7157 < testname="conftest"
7158 < modcase="lower"
7159 < if (eval $ac_compile) 2>/dev/null ; then
7160 <    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
7161 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
7162 <    if test -z "$MOD" ; then
7163 <        MOD=`ls CONFTEST* 2>/dev/null \
7164 <                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
7165 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
7166 <        if test -n "$MOD" ; then
7167 <            testname="CONFTEST"
7168 <            modcase="upper"
7169 <        fi
7170 <    fi
7171 <    if test -z "$MOD" ; then
7172 <        { $as_echo "$as_me:$LINENO: result: unknown" >&5
7173 < $as_echo "unknown" >&6; }
7174 <        # Use mod if we can't figure it out
7175 <        MOD="mod"
7176 <    else
7177 <        { $as_echo "$as_me:$LINENO: result: $MOD" >&5
7178 < $as_echo "$MOD" >&6; }
7179 <    fi
7180 <    if test -s work.pcl ; then
7181 <        { $as_echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
7182 < $as_echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
7183 <    fi
4723 > # Automatic detection of sharpbang formula starts here
4724 >     else
4725 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
4726 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
4727 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel sharpbang invocation to start perl" >&5
4728 > $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
4729 > if ${ac_cv_sys_kernshrpbang_perl+:} false; then :
4730 >  $as_echo_n "(cached) " >&6
4731   else
4732 <    { $as_echo "$as_me:$LINENO: result: unknown" >&5
4733 < $as_echo "unknown" >&6; }
4732 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
4733 >        if test "x$_somian_kspb_perl" == x
4734 >          then _somian_ksbp_warn_empty='durnit'
4735 >          else
4736 >          case "A$_somian_kspb_perl" in
4737 >                 A#!*perl* )
4738 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
4739 >                        ;;
4740 >                     A*    )  _somian_ksbp_warn_defau='trouble'
4741 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
4742 >          esac
4743 >        fi
4744 >
4745   fi
4746 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_kernshrpbang_perl" >&5
4747 + $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
4748 + # The above prints Checking ... result message to user.
4749 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4750  
4751 +    if test A${_somian_ksbp_warn_empty+set} == Aset
4752 +      then   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
4753 + $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
4754 +    fi
4755 + # Inform user after printing result value
4756 +    if test A${_somian_ksbp_warn_defau+set} == Aset
4757 +      then { $as_echo "$as_me:${as_lineno-$LINENO}: Maybe Not good -" >&5
4758 + $as_echo "$as_me: Maybe Not good -" >&6;}
4759 +           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
4760 + $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
4761 +      else { $as_echo "$as_me:${as_lineno-$LINENO}: OK Good result - " >&5
4762 + $as_echo "$as_me: OK Good result - " >&6;}
4763 +           { $as_echo "$as_me:${as_lineno-$LINENO}: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
4764 + $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
4765 +    fi
4766 +  fi
4767  
4768 + # Find a good install program.  We prefer a C program (faster),
4769 + # so one script is as good as another.  But avoid the broken or
4770 + # incompatible versions:
4771 + # SysV /etc/install, /usr/sbin/install
4772 + # SunOS /usr/etc/install
4773 + # IRIX /sbin/install
4774 + # AIX /bin/install
4775 + # AmigaOS /C/install, which installs bootblocks on floppy discs
4776 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
4777 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
4778 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
4779 + # OS/2's system install, which has a completely different semantic
4780 + # ./install, which can be erroneously created by make from ./install.sh.
4781 + # Reject install programs that cannot install multiple files.
4782 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
4783 + $as_echo_n "checking for a BSD-compatible install... " >&6; }
4784 + if test -z "$INSTALL"; then
4785 + if ${ac_cv_path_install+:} false; then :
4786 +  $as_echo_n "(cached) " >&6
4787 + else
4788 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4789 + for as_dir in $PATH
4790 + do
4791 +  IFS=$as_save_IFS
4792 +  test -z "$as_dir" && as_dir=.
4793 +    # Account for people who put trailing slashes in PATH elements.
4794 + case $as_dir/ in #((
4795 +  ./ | .// | /[cC]/* | \
4796 +  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
4797 +  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
4798 +  /usr/ucb/* ) ;;
4799 +  *)
4800 +    # OSF1 and SCO ODT 3.0 have their own names for install.
4801 +    # Don't use installbsd from OSF since it installs stuff as root
4802 +    # by default.
4803 +    for ac_prog in ginstall scoinst install; do
4804 +      for ac_exec_ext in '' $ac_executable_extensions; do
4805 +        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
4806 +          if test $ac_prog = install &&
4807 +            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4808 +            # AIX install.  It has an incompatible calling convention.
4809 +            :
4810 +          elif test $ac_prog = install &&
4811 +            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4812 +            # program-specific install script used by HP pwplus--don't use.
4813 +            :
4814 +          else
4815 +            rm -rf conftest.one conftest.two conftest.dir
4816 +            echo one > conftest.one
4817 +            echo two > conftest.two
4818 +            mkdir conftest.dir
4819 +            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
4820 +              test -s conftest.one && test -s conftest.two &&
4821 +              test -s conftest.dir/conftest.one &&
4822 +              test -s conftest.dir/conftest.two
4823 +            then
4824 +              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
4825 +              break 3
4826 +            fi
4827 +          fi
4828 +        fi
4829 +      done
4830 +    done
4831 +    ;;
4832 + esac
4833  
4834 +  done
4835 + IFS=$as_save_IFS
4836  
4837 + rm -rf conftest.one conftest.two conftest.dir
4838  
4839 < # Check for module include path (some use -I, some (Solaris) use -M, some
4840 < # (absoft) use -p).
4841 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
4842 < # specified, work.pcl and work.pc are created.  However, if you specify
4843 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
4844 < # Use the module made above
4845 < { $as_echo "$as_me:$LINENO: checking for module directory path flag" >&5
4846 < $as_echo_n "checking for module directory path flag... " >&6; }
4847 < rm -f conftest*
4848 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
4849 < rm -f work*
4850 < cat >conftest.$ac_ext <<EOF
4851 <        module conftest
7206 <        integer n
7207 <        parameter (n=1)
7208 <        end module conftest
7209 < EOF
7210 < # SGI and absoft compilers generates module name in upper case!
7211 < testname="conftest"
7212 < if (eval $ac_compile) 2>/dev/null ; then
7213 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
7214 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
7215 <   if test -n "$mod" ; then
7216 <      testname="CONFTEST"
7217 <   fi
7218 <   madedir=0
7219 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
7220 <   cp $testname.$MOD conf
7221 <   rm -f conftest* CONFTEST*
7222 <   cat >conftest1.$ac_ext <<EOF
7223 <        program main
7224 <        use conftest
7225 <        print *, n
7226 <        end
7227 < EOF
7228 <   F90_WORK_FILES_ARG=""
7229 <   F90MODINCSPEC=""
7230 <   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
7231 <       MODDIRFLAG="-I"
7232 <       F90MODINCSPEC="-I<dir>"
7233 <       { $as_echo "$as_me:$LINENO: result: -I" >&5
7234 < $as_echo "-I" >&6; }
7235 <   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
7236 <       MODDIRFLAG="-M"
7237 <       F90MODINCSPEC="-M<dir>"
7238 <       { $as_echo "$as_me:$LINENO: result: -M" >&5
7239 < $as_echo "-M" >&6; }
7240 <   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
7241 <       MODDIRFLAG="-p"
7242 <       F90MODINCSPEC="-p<dir>"
7243 <       { $as_echo "$as_me:$LINENO: result: -p" >&5
7244 < $as_echo "-p" >&6; }
7245 <   elif test -s work.pc ; then
7246 <        cp work.pc conf/mpimod.pc
7247 <        echo "mpimod.pc" > conf/mpimod.pcl
7248 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
7249 <        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
7250 <            MODDIRFLAG='-cl,mpimod.pcl'
7251 <            { $as_echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
7252 < $as_echo "-cl,filename where filename contains a list of files and directories" >&6; }
7253 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
7254 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
4839 > fi
4840 >  if test "${ac_cv_path_install+set}" = set; then
4841 >    INSTALL=$ac_cv_path_install
4842 >  else
4843 >    # As a last resort, use the slow shell script.  Don't cache a
4844 >    # value for INSTALL within a source directory, because that will
4845 >    # break other packages using the cache if that directory is
4846 >    # removed, or if the value is a relative name.
4847 >    INSTALL=$ac_install_sh
4848 >  fi
4849 > fi
4850 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
4851 > $as_echo "$INSTALL" >&6; }
4852  
4853 <        else
4854 <            # The version of the Intel compiler that I have refuses to let
4855 <            # you put the "work catalog" list anywhere but the current
7259 <            # directory. For example, you cannot in
7260 <         :
7261 <        fi
7262 <   fi
7263 <   if test -z "MODDIRFLAG" ; then
7264 <       { $as_echo "$as_me:$LINENO: result: unknown" >&5
7265 < $as_echo "unknown" >&6; }
7266 <   fi
4853 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
4854 > # It thinks the first close brace ends the variable substitution.
4855 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
4856  
4857 + test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
4858  
4859 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
7270 <   if test $madedir = 1 ; then rmdir conf ; fi
7271 < fi
4859 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
4860  
4861 <
4862 < { $as_echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
4863 < $as_echo_n "checking for Fortran 90 module file names... " >&6; }
4864 < if test "${ac_cv_f90_module_names+set}" = set; then
4861 > case "x$INSTALL" in
4862 >   x/*) ;;
4863 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
4864 > esac
4865 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f -m 755"
4866 > # Extract the first word of "ar", so it can be a program name with args.
4867 > set dummy ar; ac_word=$2
4868 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4869 > $as_echo_n "checking for $ac_word... " >&6; }
4870 > if ${ac_cv_prog_AR+:} false; then :
4871    $as_echo_n "(cached) " >&6
4872   else
4873 <  ac_ext=${ac_fc_srcext-f}
4874 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7281 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7282 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7283 <
7284 < # carry out the test in a new directory, so that we don't miss anything
7285 < mkdir conftest
7286 < cd conftest
7287 < cat >conftest.$ac_ext <<_ACEOF
7288 < MODULE Bar
7289 < END MODULE Bar
7290 < _ACEOF
7291 < 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
7309 <  ac_cv_f90_module_names=
7310 < ac_file_list=*
7311 < for ac_file in $ac_file_list; do
7312 <   case $ac_file in
7313 <      # don't care for original source and object files
7314 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
7315 <          :
7316 <          ;;
7317 <      # look for new files derived from the file name
7318 <      *conftest*)
7319 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
7320 <            ac_exists=false
7321 <  for ac_i in $ac_cv_f90_module_names; do
7322 <    if test x"$ac_pat" = x"$ac_i"; then
7323 <      ac_exists=true
7324 <      break
7325 <    fi
7326 <  done
7327 <
7328 <  if test x"$ac_exists" = xtrue; then
7329 <  :
4873 >  if test -n "$AR"; then
4874 >  ac_cv_prog_AR="$AR" # Let the user override the test.
4875   else
4876 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4877 < fi
4878 <
4879 <          ;;
4880 <      # look for new files derived from the module name,
4881 <      # with different case translation schemes
4882 <      *Bar*)
4883 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
4884 <            ac_exists=false
4885 <  for ac_i in $ac_cv_f90_module_names; do
4886 <    if test x"$ac_pat" = x"$ac_i"; then
4887 <      ac_exists=true
7343 <      break
7344 <    fi
4876 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4877 > for as_dir in $PATH
4878 > do
4879 >  IFS=$as_save_IFS
4880 >  test -z "$as_dir" && as_dir=.
4881 >    for ac_exec_ext in '' $ac_executable_extensions; do
4882 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4883 >    ac_cv_prog_AR="ar"
4884 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4885 >    break 2
4886 >  fi
4887 > done
4888    done
4889 + IFS=$as_save_IFS
4890  
4891 <  if test x"$ac_exists" = xtrue; then
4892 <  :
4891 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
4892 > fi
4893 > fi
4894 > AR=$ac_cv_prog_AR
4895 > if test -n "$AR"; then
4896 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
4897 > $as_echo "$AR" >&6; }
4898   else
4899 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4899 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4900 > $as_echo "no" >&6; }
4901   fi
4902  
7353 –          ;;
7354 –      *bar*)
7355 –          ac_pat=`echo $ac_file | sed s/bar/%module%/`
7356 –            ac_exists=false
7357 –  for ac_i in $ac_cv_f90_module_names; do
7358 –    if test x"$ac_pat" = x"$ac_i"; then
7359 –      ac_exists=true
7360 –      break
7361 –    fi
7362 –  done
4903  
4904 <  if test x"$ac_exists" = xtrue; then
4905 <  :
4906 < else
4907 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4908 < fi
4904 > if test "$AR" = "NONE"; then
4905 >  cat >confcache <<\_ACEOF
4906 > # This file is a shell script that caches the results of configure
4907 > # tests run on this system so they can be shared between configure
4908 > # scripts and configure runs, see configure's option --config-cache.
4909 > # It is not useful on other systems.  If it contains results you don't
4910 > # want to keep, you may remove or edit it.
4911 > #
4912 > # config.status only pays attention to the cache file if you give it
4913 > # the --recheck option to rerun configure.
4914 > #
4915 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
4916 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
4917 > # following values.
4918  
4919 <          ;;
4920 <      *BAR*)
4921 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
4922 <            ac_exists=false
4923 <  for ac_i in $ac_cv_f90_module_names; do
4924 <    if test x"$ac_pat" = x"$ac_i"; then
4925 <      ac_exists=true
4926 <      break
4927 <    fi
4919 > _ACEOF
4920 >
4921 > # The following way of writing the cache mishandles newlines in values,
4922 > # but we know of no workaround that is simple, portable, and efficient.
4923 > # So, we kill variables containing newlines.
4924 > # Ultrix sh set writes to stderr and can't be redirected directly,
4925 > # and sets the high bit in the cache file unless we assign to the vars.
4926 > (
4927 >  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
4928 >    eval ac_val=\$$ac_var
4929 >    case $ac_val in #(
4930 >    *${as_nl}*)
4931 >      case $ac_var in #(
4932 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
4933 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
4934 >      esac
4935 >      case $ac_var in #(
4936 >      _ | IFS | as_nl) ;; #(
4937 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
4938 >      *) { eval $ac_var=; unset $ac_var;} ;;
4939 >      esac ;;
4940 >    esac
4941    done
4942  
4943 <  if test x"$ac_exists" = xtrue; then
4944 <  :
4945 < else
4946 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
4943 >  (set) 2>&1 |
4944 >    case $as_nl`(ac_space=' '; set) 2>&1` in #(
4945 >    *${as_nl}ac_space=\ *)
4946 >      # `set' does not quote correctly, so add quotes: double-quote
4947 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
4948 >      sed -n \
4949 >        "s/'/'\\\\''/g;
4950 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4951 >      ;; #(
4952 >    *)
4953 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
4954 >      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
4955 >      ;;
4956 >    esac |
4957 >    sort
4958 > ) |
4959 >  sed '
4960 >     /^ac_cv_env_/b end
4961 >     t clear
4962 >     :clear
4963 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4964 >     t end
4965 >     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4966 >     :end' >>confcache
4967 > if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
4968 >  if test -w "$cache_file"; then
4969 >    if test "x$cache_file" != "x/dev/null"; then
4970 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
4971 > $as_echo "$as_me: updating cache $cache_file" >&6;}
4972 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
4973 >        cat confcache >"$cache_file"
4974 >      else
4975 >        case $cache_file in #(
4976 >        */* | ?:*)
4977 >          mv -f confcache "$cache_file"$$ &&
4978 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
4979 >        *)
4980 >          mv -f confcache "$cache_file" ;;
4981 >        esac
4982 >      fi
4983 >    fi
4984 >  else
4985 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
4986 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
4987 >  fi
4988   fi
4989 <
4990 <          ;;
4991 <       # Other files - we have no idea how they are generated
4992 <       *)
4993 <          { $as_echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
4994 < $as_echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
4995 <          ;;
4996 <   esac
4989 > rm -f confcache
4990 >  exit 1
4991 > fi
4992 > # Extract the first word of "ps", so it can be a program name with args.
4993 > set dummy ps; ac_word=$2
4994 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4995 > $as_echo_n "checking for $ac_word... " >&6; }
4996 > if ${ac_cv_path_PS+:} false; then :
4997 >  $as_echo_n "(cached) " >&6
4998 > else
4999 >  case $PS in
5000 >  [\\/]* | ?:[\\/]*)
5001 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
5002 >  ;;
5003 >  *)
5004 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5005 > for as_dir in $PATH
5006 > do
5007 >  IFS=$as_save_IFS
5008 >  test -z "$as_dir" && as_dir=.
5009 >    for ac_exec_ext in '' $ac_executable_extensions; do
5010 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5011 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
5012 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5013 >    break 2
5014 >  fi
5015   done
5016 < if test "x$ac_cv_f90_module_names" = "x"; then
5017 <  { $as_echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
7397 < $as_echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
7398 < fi
5016 >  done
5017 > IFS=$as_save_IFS
5018  
5019 +  ;;
5020 + esac
5021 + fi
5022 + PS=$ac_cv_path_PS
5023 + if test -n "$PS"; then
5024 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PS" >&5
5025 + $as_echo "$PS" >&6; }
5026   else
5027 <  $as_echo "$as_me: failed program was:" >&5
5028 < 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
7406 < $as_echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
5027 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5028 > $as_echo "no" >&6; }
5029   fi
5030  
7409 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7410 – cd ..
7411 – # cleanup
7412 – rm -rf conftest
7413 – ac_ext=${ac_fc_srcext-f}
7414 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7415 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7416 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5031  
5032 < fi
5033 < { $as_echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
5034 < $as_echo "$ac_cv_f90_module_names" >&6; } # AC_CACHE_CHECK
5032 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for POSIX or BSD ps syntax" >&5
5033 > $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
5034 > if ${ac_cv_prog_ps_syntax+:} false; then :
5035 >  $as_echo_n "(cached) " >&6
5036 > else
5037  
5038 < # We now generate a shell script that will help us to figure out the correct
5039 < # module file names, using the value of ac_cv_f90_module_names
5038 >        if $PS ax -o rss > /dev/null 2>&1; then
5039 >                ac_cv_prog_ps_ax=yes
5040 >        else
5041 >                ac_cv_prog_ps_ax=no
5042 >        fi
5043 >        if $PS -ef -o rss > /dev/null 2>&1; then
5044 >                ac_cv_prog_ps_ef=yes
5045 >        else
5046 >                ac_cv_prog_ps_ef=no
5047 >        fi
5048 >        if test "$ac_cv_prog_ps_ax" = yes; then
5049 >                ac_cv_prog_ps_syntax=BSD
5050 >        else
5051 >                if test "$ac_cv_prog_ps_ef" = yes; then
5052 >                        ac_cv_prog_ps_syntax=POSIX
5053 >                else
5054 >                        as_fn_error $? "Could not determine ps syntax" "$LINENO" 5
5055 >                fi
5056 >        fi
5057  
7425 – echo "Generating shell script modnam"
7426 –
7427 – cat > scripts/modnam << EOF
7428 – #! /bin/sh
7429 – # This script is auto-generated by configure
7430 – #
7431 – usage="\\
7432 – Usage: \$0 [FILES]
7433 –
7434 – [FILES] are Fortran 90 source files.
7435 – The output is a list of module file names that the Fortran 90 compiler
7436 – generates when compiling [FILES]."
7437 –
7438 – list=
7439 – empty=
7440 –
7441 – if test \$# -eq 0; then
7442 –   echo "\$usage"; exit 0
5058   fi
5059 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_ps_syntax" >&5
5060 + $as_echo "$ac_cv_prog_ps_syntax" >&6; }
5061  
5062 < while test \$# != 0; do
5062 > cat >>confdefs.h <<_ACEOF
5063 > #define PSCOMMAND $PS
5064 > _ACEOF
5065  
5066 <  file=\$1
7448 <  shift
5066 > if test "$ac_cv_prog_ps_syntax" = BSD; then
5067  
5068 < # strip suffix
7451 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
5068 > $as_echo "#define PSTYPE_IS_BSD 1" >>confdefs.h
5069  
5070 <  test ! -f \$file && continue
5070 > else
5071 >   if test "$ac_cv_prog_ps_syntax" = POSIX; then
5072  
5073 < # Look for module definitions and transform them to upper / lower case
7456 <  mods=\`cat \$file | sed '/^ *[mM][oO][dD][uU][lL][eE]/!d;s/^ *[mM][oO][dD][uU][lL][eE] *\([A-Za-z_][A-Za-z0-9_]*\).*\$/\1/'\`
7457 <  upper=\`echo \$mods | tr a-z A-Z\`
7458 <  lower=\`echo \$mods | tr A-Z a-z\`
5073 > $as_echo "#define PSTYPE_IS_POSIX 1" >>confdefs.h
5074  
5075 < # Here, the patterns for generating module file names were inserted by configure
5076 <  for trans in $ac_cv_f90_module_names; do
5075 >   else
5076 >       as_fn_error $? "Unknown ps syntax type!" "$LINENO" 5
5077 >   fi
5078 > fi
5079  
7463 –    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
7464 –    var=empty
7465 –    case \$pat in
7466 –       %MODULE%)
7467 –          var=upper ;;
7468 –       %Module%)
7469 –          var=mods ;;
7470 –       %module%)
7471 –          var=lower ;;
7472 –       %FILE%)
7473 –          test -n "\$mods" && var=base ;;
7474 –    esac
7475 –    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
7476 –    list="\$list \$new"
7477 –  done
7478 – done
7479 –
7480 – echo \$list
7481 – # end of configure-generated script
7482 – EOF
7483 – chmod 755 scripts/modnam
7484 –
7485 – pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
7486 – F90_MODULE_NAMES=empty
7487 – case $pat in
7488 –       %MODULE%)
7489 –          F90_MODULE_NAMES=UPPER ;;
7490 –       %Module%)
7491 –          F90_MODULE_NAMES=Mixed ;;
7492 –       %module%)
7493 –          F90_MODULE_NAMES=lower ;;
7494 –       *)
7495 –          F90_MODULE_NAMES=unknown ;;
7496 – esac
7497 –
5080   ac_ext=c
5081   ac_cpp='$CPP $CPPFLAGS'
5082   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 7502 | Line 5084 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5084   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5085  
5086  
5087 < ac_ext=c
7506 < ac_cpp='$CPP $CPPFLAGS'
7507 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7508 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7509 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7510 <
7511 <
7512 <
7513 < { $as_echo "$as_me:$LINENO: checking for asin in -lm" >&5
5087 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for asin in -lm" >&5
5088   $as_echo_n "checking for asin in -lm... " >&6; }
5089 < if test "${ac_cv_lib_m_asin+set}" = set; then
5089 > if ${ac_cv_lib_m_asin+:} false; then :
5090    $as_echo_n "(cached) " >&6
5091   else
5092    ac_check_lib_save_LIBS=$LIBS
5093   LIBS="-lm  $LIBS"
5094 < cat >conftest.$ac_ext <<_ACEOF
7521 < /* confdefs.h.  */
7522 < _ACEOF
7523 < cat confdefs.h >>conftest.$ac_ext
7524 < cat >>conftest.$ac_ext <<_ACEOF
5094 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5095   /* end confdefs.h.  */
5096  
5097   /* Override any GCC internal prototype to avoid an error.
# Line 7531 | Line 5101 | char asin ();
5101   extern "C"
5102   #endif
5103   char asin ();
7534 – #ifdef FC_DUMMY_MAIN
7535 – #ifndef FC_DUMMY_MAIN_EQ_F77
7536 – #  ifdef __cplusplus
7537 –     extern "C"
7538 – #  endif
7539 –   int FC_DUMMY_MAIN() { return 1; }
7540 – #endif
7541 – #endif
5104   int
5105   main ()
5106   {
# Line 7547 | Line 5109 | _ACEOF
5109    return 0;
5110   }
5111   _ACEOF
5112 < 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
5112 > if ac_fn_c_try_link "$LINENO"; then :
5113    ac_cv_lib_m_asin=yes
5114   else
5115 <  $as_echo "$as_me: failed program was:" >&5
7574 < sed 's/^/| /' conftest.$ac_ext >&5
7575 <
7576 <        ac_cv_lib_m_asin=no
5115 >  ac_cv_lib_m_asin=no
5116   fi
5117 <
5118 < rm -rf conftest.dSYM
7580 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7581 <      conftest$ac_exeext conftest.$ac_ext
5117 > rm -f core conftest.err conftest.$ac_objext \
5118 >    conftest$ac_exeext conftest.$ac_ext
5119   LIBS=$ac_check_lib_save_LIBS
5120   fi
5121 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
5121 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_asin" >&5
5122   $as_echo "$ac_cv_lib_m_asin" >&6; }
5123 < if test $ac_cv_lib_m_asin = yes; then
5123 > if test "x$ac_cv_lib_m_asin" = xyes; then :
5124    cat >>confdefs.h <<_ACEOF
5125   #define HAVE_LIBM 1
5126   _ACEOF
# Line 7595 | Line 5132 | fi
5132   fi
5133  
5134  
5135 < { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
5136   $as_echo_n "checking for ANSI C header files... " >&6; }
5137 < if test "${ac_cv_header_stdc+set}" = set; then
5137 > if ${ac_cv_header_stdc+:} false; then :
5138    $as_echo_n "(cached) " >&6
5139   else
5140 <  cat >conftest.$ac_ext <<_ACEOF
7604 < /* confdefs.h.  */
7605 < _ACEOF
7606 < cat confdefs.h >>conftest.$ac_ext
7607 < cat >>conftest.$ac_ext <<_ACEOF
5140 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5141   /* end confdefs.h.  */
5142   #include <stdlib.h>
5143   #include <stdarg.h>
5144   #include <string.h>
5145   #include <float.h>
5146  
7614 – #ifdef FC_DUMMY_MAIN
7615 – #ifndef FC_DUMMY_MAIN_EQ_F77
7616 – #  ifdef __cplusplus
7617 –     extern "C"
7618 – #  endif
7619 –   int FC_DUMMY_MAIN() { return 1; }
7620 – #endif
7621 – #endif
5147   int
5148   main ()
5149   {
# Line 7627 | Line 5152 | _ACEOF
5152    return 0;
5153   }
5154   _ACEOF
5155 < 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
5155 > if ac_fn_c_try_compile "$LINENO"; then :
5156    ac_cv_header_stdc=yes
5157   else
5158 <  $as_echo "$as_me: failed program was:" >&5
7651 < sed 's/^/| /' conftest.$ac_ext >&5
7652 <
7653 <        ac_cv_header_stdc=no
5158 >  ac_cv_header_stdc=no
5159   fi
7655 –
5160   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5161  
5162   if test $ac_cv_header_stdc = yes; then
5163    # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5164 <  cat >conftest.$ac_ext <<_ACEOF
7661 < /* confdefs.h.  */
7662 < _ACEOF
7663 < cat confdefs.h >>conftest.$ac_ext
7664 < cat >>conftest.$ac_ext <<_ACEOF
5164 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5165   /* end confdefs.h.  */
5166   #include <string.h>
5167  
5168   _ACEOF
5169   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5170 <  $EGREP "memchr" >/dev/null 2>&1; then
5171 <  :
5170 >  $EGREP "memchr" >/dev/null 2>&1; then :
5171 >
5172   else
5173    ac_cv_header_stdc=no
5174   fi
# Line 7678 | Line 5178 | if test $ac_cv_header_stdc = yes; then
5178  
5179   if test $ac_cv_header_stdc = yes; then
5180    # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5181 <  cat >conftest.$ac_ext <<_ACEOF
7682 < /* confdefs.h.  */
7683 < _ACEOF
7684 < cat confdefs.h >>conftest.$ac_ext
7685 < cat >>conftest.$ac_ext <<_ACEOF
5181 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5182   /* end confdefs.h.  */
5183   #include <stdlib.h>
5184  
5185   _ACEOF
5186   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5187 <  $EGREP "free" >/dev/null 2>&1; then
5188 <  :
5187 >  $EGREP "free" >/dev/null 2>&1; then :
5188 >
5189   else
5190    ac_cv_header_stdc=no
5191   fi
# Line 7699 | Line 5195 | if test $ac_cv_header_stdc = yes; then
5195  
5196   if test $ac_cv_header_stdc = yes; then
5197    # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5198 <  if test "$cross_compiling" = yes; then
5198 >  if test "$cross_compiling" = yes; then :
5199    :
5200   else
5201 <  cat >conftest.$ac_ext <<_ACEOF
7706 < /* confdefs.h.  */
7707 < _ACEOF
7708 < cat confdefs.h >>conftest.$ac_ext
7709 < cat >>conftest.$ac_ext <<_ACEOF
5201 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5202   /* end confdefs.h.  */
5203   #include <ctype.h>
5204   #include <stdlib.h>
# Line 7733 | Line 5225 | _ACEOF
5225    return 0;
5226   }
5227   _ACEOF
5228 < 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
5228 > if ac_fn_c_try_run "$LINENO"; then :
5229  
5230 < ( exit $ac_status )
5231 < ac_cv_header_stdc=no
5230 > else
5231 >  ac_cv_header_stdc=no
5232   fi
5233 < rm -rf conftest.dSYM
5234 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
5233 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
5234 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
5235   fi
5236  
7771 –
5237   fi
5238   fi
5239 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
5239 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
5240   $as_echo "$ac_cv_header_stdc" >&6; }
5241   if test $ac_cv_header_stdc = yes; then
5242  
5243 < cat >>confdefs.h <<\_ACEOF
7779 < #define STDC_HEADERS 1
7780 < _ACEOF
5243 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
5244  
5245   fi
5246  
5247   # On IRIX 5.3, sys/types and inttypes.h are conflicting.
7785 –
7786 –
7787 –
7788 –
7789 –
7790 –
7791 –
7792 –
7793 –
5248   for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5249                    inttypes.h stdint.h unistd.h
5250 < do
5251 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
5252 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
5253 < $as_echo_n "checking for $ac_header... " >&6; }
5254 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
7801 <  $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
5250 > do :
5251 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
5252 > ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
5253 > "
5254 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
5255    cat >>confdefs.h <<_ACEOF
5256   #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
5257   _ACEOF
# Line 7858 | Line 5266 | done
5266   #
5267  
5268   # Check whether --with-zlib was given.
5269 < if test "${with_zlib+set}" = set; then
5269 > if test "${with_zlib+set}" = set; then :
5270    withval=$with_zlib; zlib_dir="$withval"
5271   else
5272                  zlib_dir="not_set"
# Line 7871 | Line 5279 | if test "$zlib_dir" != "not_set" ; then
5279    then
5280      ZLIB_HOME="$zlib_dir"
5281    else
5282 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5282 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5283   $as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5284          ZLIB_HOME=/usr/local
5285          if test ! -f "${ZLIB_HOME}/include/zlib.h"
# Line 7896 | Line 5304 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5304   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5305   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5306  
5307 <        { $as_echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
5307 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inflateEnd in -lz" >&5
5308   $as_echo_n "checking for inflateEnd in -lz... " >&6; }
5309 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
5309 > if ${ac_cv_lib_z_inflateEnd+:} false; then :
5310    $as_echo_n "(cached) " >&6
5311   else
5312    ac_check_lib_save_LIBS=$LIBS
5313   LIBS="-lz  $LIBS"
5314 < cat >conftest.$ac_ext <<_ACEOF
7907 < /* confdefs.h.  */
7908 < _ACEOF
7909 < cat confdefs.h >>conftest.$ac_ext
7910 < cat >>conftest.$ac_ext <<_ACEOF
5314 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5315   /* end confdefs.h.  */
5316  
5317   /* Override any GCC internal prototype to avoid an error.
# Line 7917 | Line 5321 | char inflateEnd ();
5321   extern "C"
5322   #endif
5323   char inflateEnd ();
7920 – #ifdef FC_DUMMY_MAIN
7921 – #ifndef FC_DUMMY_MAIN_EQ_F77
7922 – #  ifdef __cplusplus
7923 –     extern "C"
7924 – #  endif
7925 –   int FC_DUMMY_MAIN() { return 1; }
7926 – #endif
7927 – #endif
5324   int
5325   main ()
5326   {
# Line 7933 | Line 5329 | _ACEOF
5329    return 0;
5330   }
5331   _ACEOF
5332 < 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
5332 > if ac_fn_c_try_link "$LINENO"; then :
5333    ac_cv_lib_z_inflateEnd=yes
5334   else
5335 <  $as_echo "$as_me: failed program was:" >&5
7960 < sed 's/^/| /' conftest.$ac_ext >&5
7961 <
7962 <        ac_cv_lib_z_inflateEnd=no
5335 >  ac_cv_lib_z_inflateEnd=no
5336   fi
5337 <
5338 < rm -rf conftest.dSYM
7966 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7967 <      conftest$ac_exeext conftest.$ac_ext
5337 > rm -f core conftest.err conftest.$ac_objext \
5338 >    conftest$ac_exeext conftest.$ac_ext
5339   LIBS=$ac_check_lib_save_LIBS
5340   fi
5341 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
5342 < $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
5343 < if test $ac_cv_lib_z_inflateEnd = yes; then
5344 <  zlib_cv_libz=yes
7974 < else
7975 <  zlib_cv_libz=no
7976 < fi
7977 <
7978 <        if test "${ac_cv_header_zlib_h+set}" = set; then
7979 <  { $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; }
5341 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_inflateEnd" >&5
5342 > $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
5343 > if test "x$ac_cv_lib_z_inflateEnd" = xyes; then :
5344 >  zlib_cv_libz=yes
5345   else
5346 <  # 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
5346 >  zlib_cv_libz=no
5347   fi
5348  
5349 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5350 < { $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
5349 >        ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
5350 > if test "x$ac_cv_header_zlib_h" = xyes; then :
5351    zlib_cv_zlib_h=yes
5352   else
5353    zlib_cv_zlib_h=no
# Line 8123 | Line 5363 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5363  
5364          if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
5365  
5366 < cat >>confdefs.h <<\_ACEOF
8127 < #define HAVE_ZLIB_H 1
8128 < _ACEOF
5366 > $as_echo "#define HAVE_ZLIB_H 1" >>confdefs.h
5367  
5368  
5369 < cat >>confdefs.h <<\_ACEOF
8132 < #define HAVE_LIBZ 1
8133 < _ACEOF
5369 > $as_echo "#define HAVE_LIBZ 1" >>confdefs.h
5370  
5371                  ZLIB_INC_DIR="${ZLIB_HOME}/include"
5372                  ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
5373                  ZLIB="-lz"
5374          else
5375 <                { $as_echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
5375 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking zlib in ${ZLIB_HOME}" >&5
5376   $as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
5377                  ZLIB_INC_DIR=
5378                  ZLIB_LIB_DIR=
5379                  ZLIB=
5380                  LDFLAGS="$ZLIB_OLD_LDFLAGS"
5381                  CFLAGS="$ZLIB_OLD_CFLAGS"
5382 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
5382 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5383   $as_echo "failed" >&6; }
5384                  echo ""
5385                  echo "*********************************************************"
5386                  echo "* WARNING: Could not find a working zlib installation   *"
5387 <                echo "* If you need OOPSE to be able to deal with compressed  *"
5387 >                echo "* If you need OpenMD to be able to deal with compressed *"
5388                  echo "* trajectory dump files be sure to specify a valid zlib *"
5389                  echo "* installation with --with-zlib=DIR                     *"
5390                  echo "*                                                       *"
5391 <                echo "* OOPSE will still work without zlib installed.         *"
5391 >                echo "* OpenMD will still work without zlib installed.        *"
5392                  echo "*********************************************************"
5393                  echo ""
5394          fi
# Line 8167 | Line 5403 | fi
5403   #
5404  
5405   # Check whether --with-fftw was given.
5406 < if test "${with_fftw+set}" = set; then
5406 > if test "${with_fftw+set}" = set; then :
5407    withval=$with_fftw; fftw_dir="$withval"
5408   else
5409               fftw_dir="not_set"
# Line 8178 | Line 5414 | if test "$fftw_dir" != "no"; then
5414      if test -d "$fftw_dir"; then
5415        FFTW_HOME="$fftw_dir"
5416      else
5417 <      { $as_echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
5417 >      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
5418   $as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
5419        FFTW_HOME=/usr/local
5420        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 5436 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5436   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5437   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5438  
5439 <      { $as_echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
5439 >      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
5440   $as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
5441 < if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
5441 > if ${ac_cv_lib_fftw3_fftw_execute+:} false; then :
5442    $as_echo_n "(cached) " >&6
5443   else
5444    ac_check_lib_save_LIBS=$LIBS
5445   LIBS="-lfftw3  $LIBS"
5446 < cat >conftest.$ac_ext <<_ACEOF
8211 < /* confdefs.h.  */
8212 < _ACEOF
8213 < cat confdefs.h >>conftest.$ac_ext
8214 < cat >>conftest.$ac_ext <<_ACEOF
5446 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5447   /* end confdefs.h.  */
5448  
5449   /* Override any GCC internal prototype to avoid an error.
# Line 8221 | Line 5453 | char fftw_execute ();
5453   extern "C"
5454   #endif
5455   char fftw_execute ();
8224 – #ifdef FC_DUMMY_MAIN
8225 – #ifndef FC_DUMMY_MAIN_EQ_F77
8226 – #  ifdef __cplusplus
8227 –     extern "C"
8228 – #  endif
8229 –   int FC_DUMMY_MAIN() { return 1; }
8230 – #endif
8231 – #endif
5456   int
5457   main ()
5458   {
# Line 8237 | Line 5461 | _ACEOF
5461    return 0;
5462   }
5463   _ACEOF
5464 < rm -f conftest.$ac_objext conftest$ac_exeext
8241 < 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
5464 > if ac_fn_c_try_link "$LINENO"; then :
5465    ac_cv_lib_fftw3_fftw_execute=yes
5466   else
5467 <  $as_echo "$as_me: failed program was:" >&5
8264 < sed 's/^/| /' conftest.$ac_ext >&5
8265 <
8266 <        ac_cv_lib_fftw3_fftw_execute=no
5467 >  ac_cv_lib_fftw3_fftw_execute=no
5468   fi
5469 <
5470 < rm -rf conftest.dSYM
8270 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8271 <      conftest$ac_exeext conftest.$ac_ext
5469 > rm -f core conftest.err conftest.$ac_objext \
5470 >    conftest$ac_exeext conftest.$ac_ext
5471   LIBS=$ac_check_lib_save_LIBS
5472   fi
5473 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
5473 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
5474   $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
5475 < if test $ac_cv_lib_fftw3_fftw_execute = yes; then
5475 > if test "x$ac_cv_lib_fftw3_fftw_execute" = xyes; then :
5476    fftw_cv_libfftw3=yes
5477   else
5478    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
5479   fi
5480  
5481 < rm -f conftest.err conftest.$ac_ext
5482 < { $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
8407 < else
8408 <  ac_cv_header_fftw3_h=$ac_header_preproc
8409 < fi
8410 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8411 < $as_echo "$ac_cv_header_fftw3_h" >&6; }
8412 <
8413 < fi
8414 < if test $ac_cv_header_fftw3_h = yes; then
5481 >      ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
5482 > if test "x$ac_cv_header_fftw3_h" = xyes; then :
5483    fftw_cv_fftw3_h=yes
5484   else
5485    fftw_cv_fftw3_h=no
# Line 8419 | Line 5487 | fi
5487  
5488  
5489        if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
5490 <        { $as_echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
5490 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -lfftw" >&5
5491   $as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
5492 < if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
5492 > if ${ac_cv_lib_fftw_fftwnd_one+:} false; then :
5493    $as_echo_n "(cached) " >&6
5494   else
5495    ac_check_lib_save_LIBS=$LIBS
5496   LIBS="-lfftw  $LIBS"
5497 < cat >conftest.$ac_ext <<_ACEOF
8430 < /* confdefs.h.  */
8431 < _ACEOF
8432 < cat confdefs.h >>conftest.$ac_ext
8433 < cat >>conftest.$ac_ext <<_ACEOF
5497 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5498   /* end confdefs.h.  */
5499  
5500   /* Override any GCC internal prototype to avoid an error.
# Line 8440 | Line 5504 | char fftwnd_one ();
5504   extern "C"
5505   #endif
5506   char fftwnd_one ();
8443 – #ifdef FC_DUMMY_MAIN
8444 – #ifndef FC_DUMMY_MAIN_EQ_F77
8445 – #  ifdef __cplusplus
8446 –     extern "C"
8447 – #  endif
8448 –   int FC_DUMMY_MAIN() { return 1; }
8449 – #endif
8450 – #endif
5507   int
5508   main ()
5509   {
# Line 8456 | Line 5512 | _ACEOF
5512    return 0;
5513   }
5514   _ACEOF
5515 < 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
5515 > if ac_fn_c_try_link "$LINENO"; then :
5516    ac_cv_lib_fftw_fftwnd_one=yes
5517   else
5518 <  $as_echo "$as_me: failed program was:" >&5
8483 < sed 's/^/| /' conftest.$ac_ext >&5
8484 <
8485 <        ac_cv_lib_fftw_fftwnd_one=no
5518 >  ac_cv_lib_fftw_fftwnd_one=no
5519   fi
5520 <
5521 < rm -rf conftest.dSYM
8489 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8490 <      conftest$ac_exeext conftest.$ac_ext
5520 > rm -f core conftest.err conftest.$ac_objext \
5521 >    conftest$ac_exeext conftest.$ac_ext
5522   LIBS=$ac_check_lib_save_LIBS
5523   fi
5524 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
5524 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw_fftwnd_one" >&5
5525   $as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
5526 < if test $ac_cv_lib_fftw_fftwnd_one = yes; then
5526 > if test "x$ac_cv_lib_fftw_fftwnd_one" = xyes; then :
5527    fftw_cv_libfftw=yes
5528   else
5529    fftw_cv_libfftw=no
5530   fi
5531  
5532 <        if test "${ac_cv_header_fftw_h+set}" = set; then
5533 <  { $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
5532 >        ac_fn_c_check_header_mongrel "$LINENO" "fftw.h" "ac_cv_header_fftw_h" "$ac_includes_default"
5533 > if test "x$ac_cv_header_fftw_h" = xyes; then :
5534    fftw_cv_fftw_h=yes
5535   else
5536    fftw_cv_fftw_h=no
# Line 8638 | Line 5538 | fi
5538  
5539  
5540          if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
5541 <          { $as_echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
5541 >          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -ldfftw" >&5
5542   $as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
5543 < if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
5543 > if ${ac_cv_lib_dfftw_fftwnd_one+:} false; then :
5544    $as_echo_n "(cached) " >&6
5545   else
5546    ac_check_lib_save_LIBS=$LIBS
5547   LIBS="-ldfftw  $LIBS"
5548 < cat >conftest.$ac_ext <<_ACEOF
8649 < /* confdefs.h.  */
8650 < _ACEOF
8651 < cat confdefs.h >>conftest.$ac_ext
8652 < cat >>conftest.$ac_ext <<_ACEOF
5548 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5549   /* end confdefs.h.  */
5550  
5551   /* Override any GCC internal prototype to avoid an error.
# Line 8659 | Line 5555 | char fftwnd_one ();
5555   extern "C"
5556   #endif
5557   char fftwnd_one ();
8662 – #ifdef FC_DUMMY_MAIN
8663 – #ifndef FC_DUMMY_MAIN_EQ_F77
8664 – #  ifdef __cplusplus
8665 –     extern "C"
8666 – #  endif
8667 –   int FC_DUMMY_MAIN() { return 1; }
8668 – #endif
8669 – #endif
5558   int
5559   main ()
5560   {
# Line 8675 | Line 5563 | _ACEOF
5563    return 0;
5564   }
5565   _ACEOF
5566 < 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
5566 > if ac_fn_c_try_link "$LINENO"; then :
5567    ac_cv_lib_dfftw_fftwnd_one=yes
5568   else
5569 <  $as_echo "$as_me: failed program was:" >&5
8702 < sed 's/^/| /' conftest.$ac_ext >&5
8703 <
8704 <        ac_cv_lib_dfftw_fftwnd_one=no
5569 >  ac_cv_lib_dfftw_fftwnd_one=no
5570   fi
5571 <
5572 < rm -rf conftest.dSYM
8708 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8709 <      conftest$ac_exeext conftest.$ac_ext
5571 > rm -f core conftest.err conftest.$ac_objext \
5572 >    conftest$ac_exeext conftest.$ac_ext
5573   LIBS=$ac_check_lib_save_LIBS
5574   fi
5575 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
5575 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
5576   $as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
5577 < if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
5577 > if test "x$ac_cv_lib_dfftw_fftwnd_one" = xyes; then :
5578    fftw_cv_libdfftw=yes
5579   else
5580    fftw_cv_libdfftw=no
5581   fi
5582  
5583 <          if test "${ac_cv_header_dfftw_h+set}" = set; then
5584 <  { $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
5583 >          ac_fn_c_check_header_mongrel "$LINENO" "dfftw.h" "ac_cv_header_dfftw_h" "$ac_includes_default"
5584 > if test "x$ac_cv_header_dfftw_h" = xyes; then :
5585    fftw_cv_dfftw_h=yes
5586   else
5587    fftw_cv_dfftw_h=no
# Line 8866 | Line 5598 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5598  
5599        if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
5600  
5601 < cat >>confdefs.h <<\_ACEOF
8870 < #define HAVE_FFTW3_H 1
8871 < _ACEOF
5601 > $as_echo "#define HAVE_FFTW3_H 1" >>confdefs.h
5602  
5603          FFTW_INC_DIR="${FFTW_HOME}/include"
5604          FFTW_LIB_DIR="${FFTW_HOME}/lib"
# Line 8876 | Line 5606 | _ACEOF
5606        else
5607          if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
5608  
5609 < cat >>confdefs.h <<\_ACEOF
8880 < #define HAVE_FFTW_H 1
8881 < _ACEOF
5609 > $as_echo "#define HAVE_FFTW_H 1" >>confdefs.h
5610  
5611            FFTW_INC_DIR="${FFTW_HOME}/include"
5612            FFTW_LIB_DIR="${FFTW_HOME}/lib"
# Line 8886 | Line 5614 | _ACEOF
5614          else
5615            if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
5616  
5617 < cat >>confdefs.h <<\_ACEOF
8890 < #define HAVE_DFFTW_H 1
8891 < _ACEOF
5617 > $as_echo "#define HAVE_DFFTW_H 1" >>confdefs.h
5618  
5619              FFTW_INC_DIR="${FFTW_HOME}/include"
5620              FFTW_LIB_DIR="${FFTW_HOME}/lib"
5621              FFTW_LIBS="-ldfftw"
5622            else
5623 <            { $as_echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
5623 >            { $as_echo "$as_me:${as_lineno-$LINENO}: checking fftw in ${FFTW_HOME}" >&5
5624   $as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
5625              FFTW_INC_DIR=
5626              FFTW_LIB_DIR=
5627              FFTW_LIBS=
5628              LDFLAGS="$FFTW_OLD_LDFLAGS"
5629              CFLAGS="$FFTW_OLD_CFLAGS"
5630 <            { $as_echo "$as_me:$LINENO: result: failed" >&5
5630 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5631   $as_echo "failed" >&6; }
5632              echo ""
5633              echo "*********************************************************"
# Line 8910 | Line 5636 | $as_echo "failed" >&6; }
5636              echo "* compute undulation spectra, be sure to specify a      *"
5637              echo "* valid fftw installation with --with-fftw=DIR          *"
5638              echo "*                                                       *"
5639 <            echo "* OOPSE will still work without fftw installed.         *"
5639 >            echo "* OpenMD will still work without fftw installed.        *"
5640              echo "*********************************************************"
5641              echo ""
5642            fi
# Line 8928 | Line 5654 | fi
5654   #
5655  
5656   # Check whether --with-qhull was given.
5657 < if test "${with_qhull+set}" = set; then
5657 > if test "${with_qhull+set}" = set; then :
5658    withval=$with_qhull; qhull_dir="$withval"
5659   else
5660    qhull_dir="not_set"
# Line 8944 | Line 5670 | if test "$qhull_dir" != "no"; then
5670       if test -d "$qhull_dir"; then
5671         QHULL_HOME="$qhull_dir"
5672       else
5673 <       { $as_echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
5673 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
5674   $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
5675         QHULL_HOME=/usr/local
5676 <       if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"; then
5676 >       if test ! -f "${QHULL_HOME}/include/qhull/libqhull.h"; then
5677            QHULL_HOME=/usr
5678         fi
5679       fi
# Line 8956 | Line 5682 | $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not
5682     # Locate qhull, if wanted
5683     #
5684     if test -n "${QHULL_HOME}"; then
5685 <        { $as_echo "$as_me:$LINENO: Checking for qhull in ${QHULL_HOME}" >&5
5685 >        { $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
5686   $as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
5687  
5688          ac_ext=c
# Line 8971 | Line 5697 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5697          LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
5698          CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
5699          CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
5700 <        if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
5701 <  { $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
5702 < $as_echo_n "checking for qhull/qhull.h... " >&6; }
8977 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8978 <  $as_echo_n "(cached) " >&6
8979 < fi
8980 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
8981 < $as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
5700 >        ac_fn_c_check_header_mongrel "$LINENO" "qhull/libqhull.h" "ac_cv_header_qhull_libqhull_h" "$ac_includes_default"
5701 > if test "x$ac_cv_header_qhull_libqhull_h" = xyes; then :
5702 >  qhull_cv_libqhull_h=yes
5703   else
5704 <  # Is the header compilable?
8984 < { $as_echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
8985 < $as_echo_n "checking qhull/qhull.h usability... " >&6; }
8986 < cat >conftest.$ac_ext <<_ACEOF
8987 < /* confdefs.h.  */
8988 < _ACEOF
8989 < cat confdefs.h >>conftest.$ac_ext
8990 < cat >>conftest.$ac_ext <<_ACEOF
8991 < /* end confdefs.h.  */
8992 < $ac_includes_default
8993 < #include <qhull/qhull.h>
8994 < _ACEOF
8995 < rm -f conftest.$ac_objext
8996 < if { (ac_try="$ac_compile"
8997 < case "(($ac_try" in
8998 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8999 <  *) ac_try_echo=$ac_try;;
9000 < esac
9001 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9002 < $as_echo "$ac_try_echo") >&5
9003 <  (eval "$ac_compile") 2>conftest.er1
9004 <  ac_status=$?
9005 <  grep -v '^ *+' conftest.er1 >conftest.err
9006 <  rm -f conftest.er1
9007 <  cat conftest.err >&5
9008 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9009 <  (exit $ac_status); } && {
9010 <         test -z "$ac_c_werror_flag" ||
9011 <         test ! -s conftest.err
9012 <       } && test -s conftest.$ac_objext; then
9013 <  ac_header_compiler=yes
9014 < else
9015 <  $as_echo "$as_me: failed program was:" >&5
9016 < sed 's/^/| /' conftest.$ac_ext >&5
9017 <
9018 <        ac_header_compiler=no
5704 >  qhull_cv_libqhull_h=no
5705   fi
5706  
9021 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9022 – { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9023 – $as_echo "$ac_header_compiler" >&6; }
5707  
5708 < # Is the header present?
5709 < { $as_echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
5710 < $as_echo_n "checking qhull/qhull.h presence... " >&6; }
5711 < cat >conftest.$ac_ext <<_ACEOF
5712 < /* confdefs.h.  */
5713 < _ACEOF
5714 < cat confdefs.h >>conftest.$ac_ext
5715 < cat >>conftest.$ac_ext <<_ACEOF
5708 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull" >&5
5709 > $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
5710 > if ${ac_cv_lib_qhull_qh_qhull+:} false; then :
5711 >  $as_echo_n "(cached) " >&6
5712 > else
5713 >  ac_check_lib_save_LIBS=$LIBS
5714 > LIBS="-lqhull  $LIBS"
5715 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5716   /* end confdefs.h.  */
5717 < #include <qhull/qhull.h>
5717 >
5718 > /* Override any GCC internal prototype to avoid an error.
5719 >   Use char because int might match the return type of a GCC
5720 >   builtin and then its argument prototype would still apply.  */
5721 > #ifdef __cplusplus
5722 > extern "C"
5723 > #endif
5724 > char qh_qhull ();
5725 > int
5726 > main ()
5727 > {
5728 > return qh_qhull ();
5729 >  ;
5730 >  return 0;
5731 > }
5732   _ACEOF
5733 < if { (ac_try="$ac_cpp conftest.$ac_ext"
5734 < case "(($ac_try" in
9038 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9039 <  *) ac_try_echo=$ac_try;;
9040 < esac
9041 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9042 < $as_echo "$ac_try_echo") >&5
9043 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9044 <  ac_status=$?
9045 <  grep -v '^ *+' conftest.er1 >conftest.err
9046 <  rm -f conftest.er1
9047 <  cat conftest.err >&5
9048 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9049 <  (exit $ac_status); } >/dev/null && {
9050 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
9051 <         test ! -s conftest.err
9052 <       }; then
9053 <  ac_header_preproc=yes
5733 > if ac_fn_c_try_link "$LINENO"; then :
5734 >  ac_cv_lib_qhull_qh_qhull=yes
5735   else
5736 <  $as_echo "$as_me: failed program was:" >&5
9056 < sed 's/^/| /' conftest.$ac_ext >&5
9057 <
9058 <  ac_header_preproc=no
5736 >  ac_cv_lib_qhull_qh_qhull=no
5737   fi
5738 <
5739 < rm -f conftest.err conftest.$ac_ext
5740 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9063 < $as_echo "$ac_header_preproc" >&6; }
9064 <
9065 < # So?  What about this header?
9066 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9067 <  yes:no: )
9068 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
9069 < $as_echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9070 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
9071 < $as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
9072 <    ac_header_preproc=yes
9073 <    ;;
9074 <  no:yes:* )
9075 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
9076 < $as_echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
9077 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&5
9078 < $as_echo "$as_me: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&2;}
9079 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
9080 < $as_echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
9081 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&5
9082 < $as_echo "$as_me: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9083 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
9084 < $as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
9085 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
9086 < $as_echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
9087 <    ( cat <<\_ASBOX
9088 < ## ------------------------------ ##
9089 < ## Report this to gezelter@nd.edu ##
9090 < ## ------------------------------ ##
9091 < _ASBOX
9092 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9093 <    ;;
9094 < esac
9095 < { $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
9096 < $as_echo_n "checking for qhull/qhull.h... " >&6; }
9097 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
9098 <  $as_echo_n "(cached) " >&6
9099 < else
9100 <  ac_cv_header_qhull_qhull_h=$ac_header_preproc
5738 > rm -f core conftest.err conftest.$ac_objext \
5739 >    conftest$ac_exeext conftest.$ac_ext
5740 > LIBS=$ac_check_lib_save_LIBS
5741   fi
5742 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
5743 < $as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
5744 <
5745 < fi
9106 < if test $ac_cv_header_qhull_qhull_h = yes; then
9107 <  qhull_cv_qhull_h=yes
5742 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull_qh_qhull" >&5
5743 > $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
5744 > if test "x$ac_cv_lib_qhull_qh_qhull" = xyes; then :
5745 >  qhull_cv_libqhull=yes
5746   else
5747 <  qhull_cv_qhull_h=no
5747 >  qhull_cv_libqhull=no
5748   fi
5749  
5750 <
5751 <        { $as_echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
5752 < $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
9115 < if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
5750 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull6" >&5
5751 > $as_echo_n "checking for qh_qhull in -lqhull6... " >&6; }
5752 > if ${ac_cv_lib_qhull6_qh_qhull+:} false; then :
5753    $as_echo_n "(cached) " >&6
5754   else
5755    ac_check_lib_save_LIBS=$LIBS
5756 < LIBS="-lqhull  $LIBS"
5757 < cat >conftest.$ac_ext <<_ACEOF
9121 < /* confdefs.h.  */
9122 < _ACEOF
9123 < cat confdefs.h >>conftest.$ac_ext
9124 < cat >>conftest.$ac_ext <<_ACEOF
5756 > LIBS="-lqhull6  $LIBS"
5757 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5758   /* end confdefs.h.  */
5759  
5760   /* Override any GCC internal prototype to avoid an error.
# Line 9131 | Line 5764 | char qh_qhull ();
5764   extern "C"
5765   #endif
5766   char qh_qhull ();
9134 – #ifdef FC_DUMMY_MAIN
9135 – #ifndef FC_DUMMY_MAIN_EQ_F77
9136 – #  ifdef __cplusplus
9137 –     extern "C"
9138 – #  endif
9139 –   int FC_DUMMY_MAIN() { return 1; }
9140 – #endif
9141 – #endif
5767   int
5768   main ()
5769   {
# Line 9147 | Line 5772 | _ACEOF
5772    return 0;
5773   }
5774   _ACEOF
5775 < rm -f conftest.$ac_objext conftest$ac_exeext
5776 < if { (ac_try="$ac_link"
9152 < case "(($ac_try" in
9153 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9154 <  *) ac_try_echo=$ac_try;;
9155 < esac
9156 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9157 < $as_echo "$ac_try_echo") >&5
9158 <  (eval "$ac_link") 2>conftest.er1
9159 <  ac_status=$?
9160 <  grep -v '^ *+' conftest.er1 >conftest.err
9161 <  rm -f conftest.er1
9162 <  cat conftest.err >&5
9163 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9164 <  (exit $ac_status); } && {
9165 <         test -z "$ac_c_werror_flag" ||
9166 <         test ! -s conftest.err
9167 <       } && test -s conftest$ac_exeext && {
9168 <         test "$cross_compiling" = yes ||
9169 <         $as_test_x conftest$ac_exeext
9170 <       }; then
9171 <  ac_cv_lib_qhull_qh_qhull=yes
5775 > if ac_fn_c_try_link "$LINENO"; then :
5776 >  ac_cv_lib_qhull6_qh_qhull=yes
5777   else
5778 <  $as_echo "$as_me: failed program was:" >&5
9174 < sed 's/^/| /' conftest.$ac_ext >&5
9175 <
9176 <        ac_cv_lib_qhull_qh_qhull=no
5778 >  ac_cv_lib_qhull6_qh_qhull=no
5779   fi
5780 <
5781 < rm -rf conftest.dSYM
9180 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9181 <      conftest$ac_exeext conftest.$ac_ext
5780 > rm -f core conftest.err conftest.$ac_objext \
5781 >    conftest$ac_exeext conftest.$ac_ext
5782   LIBS=$ac_check_lib_save_LIBS
5783   fi
5784 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
5785 < $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
5786 < if test $ac_cv_lib_qhull_qh_qhull = yes; then
5787 <  qhull_cv_libqhull=yes
5784 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull6_qh_qhull" >&5
5785 > $as_echo "$ac_cv_lib_qhull6_qh_qhull" >&6; }
5786 > if test "x$ac_cv_lib_qhull6_qh_qhull" = xyes; then :
5787 >  qhull_cv_libqhull6=yes
5788   else
5789 <  qhull_cv_libqhull=no
5789 >  qhull_cv_libqhull6=no
5790   fi
5791  
5792          LDFLAGS="$QHULL_OLD_LDFLAGS"
# Line 9197 | Line 5797 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
5797   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5798   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5799   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5800 +
5801 +
5802 +        if test "$qhull_cv_libqhull_h" = "yes" -a "$qhull_cv_libqhull" = "yes" -o "$qhull_cv_libqhull6" = "yes"; then
5803 +
5804 + $as_echo "#define HAVE_LIBQHULL_H 1" >>confdefs.h
5805 +
5806 +           if test "$qhull_cv_libqhull" = "yes"; then
5807 +
5808 + $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5809 +
5810 +                QHULL="-lqhull"
5811 +           fi
5812 +           if test "$qhull_cv_libqhull6" = "yes"; then
5813  
5814 + $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5815  
5816 <        if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
5817 <
9204 < cat >>confdefs.h <<\_ACEOF
9205 < #define HAVE_QHULL_H 1
9206 < _ACEOF
9207 <
9208 <
9209 < cat >>confdefs.h <<\_ACEOF
9210 < #define HAVE_QHULL 1
9211 < _ACEOF
9212 <
5816 >                QHULL="-lqhull6"
5817 >           fi
5818             USE_QHULL=yes
5819             QHULL_INC_DIR="${QHULL_HOME}/include"
5820             QHULL_LIB_DIR="${QHULL_HOME}/lib"
5821 <           QHULL="-lqhull"
9217 <           { $as_echo "$as_me:$LINENO: result: Working qhull found, will proceed." >&5
5821 >           { $as_echo "$as_me:${as_lineno-$LINENO}: result: Working qhull found, will proceed." >&5
5822   $as_echo "Working qhull found, will proceed." >&6; }
5823          else
5824 <           { $as_echo "$as_me:$LINENO: WARNING: " >&5
5824 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5825   $as_echo "$as_me: WARNING: " >&2;}
5826 <           { $as_echo "$as_me:$LINENO: WARNING: Could not find a working qhull installation" >&5
5826 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
5827   $as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
5828 <           { $as_echo "$as_me:$LINENO: WARNING: If you need OOPSE to be able to deal with convex    " >&5
5829 < $as_echo "$as_me: WARNING: If you need OOPSE to be able to deal with convex    " >&2;}
5830 <           { $as_echo "$as_me:$LINENO: WARNING: hulls be sure to specify a valid qhull installation " >&5
5828 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OpenMD to be able to deal with convex    " >&5
5829 > $as_echo "$as_me: WARNING: If you need OpenMD to be able to deal with convex    " >&2;}
5830 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
5831   $as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
5832 <           { $as_echo "$as_me:$LINENO: WARNING: with --with-qhull=DIR                               " >&5
5832 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR                               " >&5
5833   $as_echo "$as_me: WARNING: with --with-qhull=DIR                               " >&2;}
5834 <           { $as_echo "$as_me:$LINENO: WARNING: " >&5
5834 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5835   $as_echo "$as_me: WARNING: " >&2;}
5836 <           { $as_echo "$as_me:$LINENO: WARNING: OOPSE will still work without qhull installed.      " >&5
5837 < $as_echo "$as_me: WARNING: OOPSE will still work without qhull installed.      " >&2;}
5838 <           { $as_echo "$as_me:$LINENO: WARNING: " >&5
5836 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OpenMD will still work without qhull installed.      " >&5
5837 > $as_echo "$as_me: WARNING: OpenMD will still work without qhull installed.      " >&2;}
5838 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5839   $as_echo "$as_me: WARNING: " >&2;}
5840          fi
5841      fi
# Line 9241 | Line 5845 | fi
5845  
5846  
5847  
9244 –
5848   ac_ext=cpp
5849   ac_cpp='$CXXCPP $CPPFLAGS'
5850   ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5851   ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5852   ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5853 < { $as_echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
5853 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
5854   $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
5855   if test -z "$CXXCPP"; then
5856 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
5856 >  if ${ac_cv_prog_CXXCPP+:} false; then :
5857    $as_echo_n "(cached) " >&6
5858   else
5859        # Double quotes because CXXCPP needs to be expanded
# Line 9265 | Line 5868 | do
5868    # <limits.h> exists even on freestanding compilers.
5869    # On the NeXT, cc -E runs the code through the compiler's parser,
5870    # not just through cpp. "Syntax error" is here to catch this case.
5871 <  cat >conftest.$ac_ext <<_ACEOF
9269 < /* confdefs.h.  */
9270 < _ACEOF
9271 < cat confdefs.h >>conftest.$ac_ext
9272 < cat >>conftest.$ac_ext <<_ACEOF
5871 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5872   /* end confdefs.h.  */
5873   #ifdef __STDC__
5874   # include <limits.h>
# Line 9278 | Line 5877 | _ACEOF
5877   #endif
5878                       Syntax error
5879   _ACEOF
5880 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9282 < case "(($ac_try" in
9283 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9284 <  *) ac_try_echo=$ac_try;;
9285 < esac
9286 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9287 < $as_echo "$ac_try_echo") >&5
9288 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9289 <  ac_status=$?
9290 <  grep -v '^ *+' conftest.er1 >conftest.err
9291 <  rm -f conftest.er1
9292 <  cat conftest.err >&5
9293 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9294 <  (exit $ac_status); } >/dev/null && {
9295 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9296 <         test ! -s conftest.err
9297 <       }; then
9298 <  :
9299 < else
9300 <  $as_echo "$as_me: failed program was:" >&5
9301 < sed 's/^/| /' conftest.$ac_ext >&5
5880 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5881  
5882 + else
5883    # Broken: fails on valid input.
5884   continue
5885   fi
5886 + rm -f conftest.err conftest.i conftest.$ac_ext
5887  
9307 – rm -f conftest.err conftest.$ac_ext
9308 –
5888    # OK, works on sane cases.  Now check whether nonexistent headers
5889    # can be detected and how.
5890 <  cat >conftest.$ac_ext <<_ACEOF
9312 < /* confdefs.h.  */
9313 < _ACEOF
9314 < cat confdefs.h >>conftest.$ac_ext
9315 < cat >>conftest.$ac_ext <<_ACEOF
5890 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5891   /* end confdefs.h.  */
5892   #include <ac_nonexistent.h>
5893   _ACEOF
5894 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9320 < case "(($ac_try" in
9321 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9322 <  *) ac_try_echo=$ac_try;;
9323 < esac
9324 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9325 < $as_echo "$ac_try_echo") >&5
9326 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9327 <  ac_status=$?
9328 <  grep -v '^ *+' conftest.er1 >conftest.err
9329 <  rm -f conftest.er1
9330 <  cat conftest.err >&5
9331 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9332 <  (exit $ac_status); } >/dev/null && {
9333 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9334 <         test ! -s conftest.err
9335 <       }; then
5894 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5895    # Broken: success on invalid input.
5896   continue
5897   else
9339 –  $as_echo "$as_me: failed program was:" >&5
9340 – sed 's/^/| /' conftest.$ac_ext >&5
9341 –
5898    # Passes both tests.
5899   ac_preproc_ok=:
5900   break
5901   fi
5902 + rm -f conftest.err conftest.i conftest.$ac_ext
5903  
9347 – rm -f conftest.err conftest.$ac_ext
9348 –
5904   done
5905   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5906 < rm -f conftest.err conftest.$ac_ext
5907 < if $ac_preproc_ok; then
5906 > rm -f conftest.i conftest.err conftest.$ac_ext
5907 > if $ac_preproc_ok; then :
5908    break
5909   fi
5910  
# Line 9361 | Line 5916 | fi
5916   else
5917    ac_cv_prog_CXXCPP=$CXXCPP
5918   fi
5919 < { $as_echo "$as_me:$LINENO: result: $CXXCPP" >&5
5919 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
5920   $as_echo "$CXXCPP" >&6; }
5921   ac_preproc_ok=false
5922   for ac_cxx_preproc_warn_flag in '' yes
# Line 9372 | Line 5927 | do
5927    # <limits.h> exists even on freestanding compilers.
5928    # On the NeXT, cc -E runs the code through the compiler's parser,
5929    # not just through cpp. "Syntax error" is here to catch this case.
5930 <  cat >conftest.$ac_ext <<_ACEOF
9376 < /* confdefs.h.  */
9377 < _ACEOF
9378 < cat confdefs.h >>conftest.$ac_ext
9379 < cat >>conftest.$ac_ext <<_ACEOF
5930 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5931   /* end confdefs.h.  */
5932   #ifdef __STDC__
5933   # include <limits.h>
# Line 9385 | Line 5936 | _ACEOF
5936   #endif
5937                       Syntax error
5938   _ACEOF
5939 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9389 < case "(($ac_try" in
9390 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9391 <  *) ac_try_echo=$ac_try;;
9392 < esac
9393 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9394 < $as_echo "$ac_try_echo") >&5
9395 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9396 <  ac_status=$?
9397 <  grep -v '^ *+' conftest.er1 >conftest.err
9398 <  rm -f conftest.er1
9399 <  cat conftest.err >&5
9400 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9401 <  (exit $ac_status); } >/dev/null && {
9402 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9403 <         test ! -s conftest.err
9404 <       }; then
9405 <  :
9406 < else
9407 <  $as_echo "$as_me: failed program was:" >&5
9408 < sed 's/^/| /' conftest.$ac_ext >&5
5939 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5940  
5941 + else
5942    # Broken: fails on valid input.
5943   continue
5944   fi
5945 + rm -f conftest.err conftest.i conftest.$ac_ext
5946  
9414 – rm -f conftest.err conftest.$ac_ext
9415 –
5947    # OK, works on sane cases.  Now check whether nonexistent headers
5948    # can be detected and how.
5949 <  cat >conftest.$ac_ext <<_ACEOF
9419 < /* confdefs.h.  */
9420 < _ACEOF
9421 < cat confdefs.h >>conftest.$ac_ext
9422 < cat >>conftest.$ac_ext <<_ACEOF
5949 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5950   /* end confdefs.h.  */
5951   #include <ac_nonexistent.h>
5952   _ACEOF
5953 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9427 < case "(($ac_try" in
9428 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9429 <  *) ac_try_echo=$ac_try;;
9430 < esac
9431 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9432 < $as_echo "$ac_try_echo") >&5
9433 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9434 <  ac_status=$?
9435 <  grep -v '^ *+' conftest.er1 >conftest.err
9436 <  rm -f conftest.er1
9437 <  cat conftest.err >&5
9438 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9439 <  (exit $ac_status); } >/dev/null && {
9440 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9441 <         test ! -s conftest.err
9442 <       }; then
5953 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5954    # Broken: success on invalid input.
5955   continue
5956   else
9446 –  $as_echo "$as_me: failed program was:" >&5
9447 – sed 's/^/| /' conftest.$ac_ext >&5
9448 –
5957    # Passes both tests.
5958   ac_preproc_ok=:
5959   break
5960   fi
5961 + rm -f conftest.err conftest.i conftest.$ac_ext
5962  
9454 – rm -f conftest.err conftest.$ac_ext
9455 –
5963   done
5964   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5965 < rm -f conftest.err conftest.$ac_ext
5966 < if $ac_preproc_ok; then
5967 <  :
5965 > rm -f conftest.i conftest.err conftest.$ac_ext
5966 > if $ac_preproc_ok; then :
5967 >
5968   else
5969 <  { { $as_echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
5970 < See \`config.log' for more details." >&5
5971 < $as_echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
5972 < See \`config.log' for more details." >&2;}
9466 <   { (exit 1); exit 1; }; }
5969 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5970 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5971 > as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
5972 > See \`config.log' for more details" "$LINENO" 5; }
5973   fi
5974  
5975   ac_ext=cpp
# Line 9478 | Line 5984 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5984   #
5985  
5986   # Check whether --with-openbabel was given.
5987 < if test "${with_openbabel+set}" = set; then
5987 > if test "${with_openbabel+set}" = set; then :
5988    withval=$with_openbabel; openbabel_dir="$withval"
5989   else
5990                  openbabel_dir="not_set"
# Line 9491 | Line 5997 | if test "$openbabel_dir" != "not_set" ; then
5997    then
5998      OPENBABEL_HOME="$openbabel_dir"
5999    else
6000 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
6000 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
6001   $as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
6002          OPENBABEL_HOME=/usr/local
6003          if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
# Line 9516 | Line 6022 | ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6022          OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
6023          LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
6024          CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
6025 <        if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
6026 <  { $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9521 < $as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9522 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9523 <  $as_echo_n "(cached) " >&6
9524 < fi
9525 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9526 < $as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9527 < else
9528 <  # Is the header compilable?
9529 < { $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h usability" >&5
9530 < $as_echo_n "checking openbabel/babelconfig.h usability... " >&6; }
9531 < cat >conftest.$ac_ext <<_ACEOF
9532 < /* confdefs.h.  */
9533 < _ACEOF
9534 < cat confdefs.h >>conftest.$ac_ext
9535 < cat >>conftest.$ac_ext <<_ACEOF
9536 < /* end confdefs.h.  */
9537 < $ac_includes_default
9538 < #include <openbabel/babelconfig.h>
9539 < _ACEOF
9540 < rm -f conftest.$ac_objext
9541 < if { (ac_try="$ac_compile"
9542 < case "(($ac_try" in
9543 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9544 <  *) ac_try_echo=$ac_try;;
9545 < esac
9546 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9547 < $as_echo "$ac_try_echo") >&5
9548 <  (eval "$ac_compile") 2>conftest.er1
9549 <  ac_status=$?
9550 <  grep -v '^ *+' conftest.er1 >conftest.err
9551 <  rm -f conftest.er1
9552 <  cat conftest.err >&5
9553 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9554 <  (exit $ac_status); } && {
9555 <         test -z "$ac_cxx_werror_flag" ||
9556 <         test ! -s conftest.err
9557 <       } && test -s conftest.$ac_objext; then
9558 <  ac_header_compiler=yes
9559 < else
9560 <  $as_echo "$as_me: failed program was:" >&5
9561 < sed 's/^/| /' conftest.$ac_ext >&5
9562 <
9563 <        ac_header_compiler=no
9564 < fi
9565 <
9566 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9567 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9568 < $as_echo "$ac_header_compiler" >&6; }
9569 <
9570 < # Is the header present?
9571 < { $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h presence" >&5
9572 < $as_echo_n "checking openbabel/babelconfig.h presence... " >&6; }
9573 < cat >conftest.$ac_ext <<_ACEOF
9574 < /* confdefs.h.  */
9575 < _ACEOF
9576 < cat confdefs.h >>conftest.$ac_ext
9577 < cat >>conftest.$ac_ext <<_ACEOF
9578 < /* end confdefs.h.  */
9579 < #include <openbabel/babelconfig.h>
9580 < _ACEOF
9581 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9582 < case "(($ac_try" in
9583 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9584 <  *) ac_try_echo=$ac_try;;
9585 < esac
9586 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9587 < $as_echo "$ac_try_echo") >&5
9588 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9589 <  ac_status=$?
9590 <  grep -v '^ *+' conftest.er1 >conftest.err
9591 <  rm -f conftest.er1
9592 <  cat conftest.err >&5
9593 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9594 <  (exit $ac_status); } >/dev/null && {
9595 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9596 <         test ! -s conftest.err
9597 <       }; then
9598 <  ac_header_preproc=yes
9599 < else
9600 <  $as_echo "$as_me: failed program was:" >&5
9601 < sed 's/^/| /' conftest.$ac_ext >&5
9602 <
9603 <  ac_header_preproc=no
9604 < fi
9605 <
9606 < rm -f conftest.err conftest.$ac_ext
9607 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9608 < $as_echo "$ac_header_preproc" >&6; }
9609 <
9610 < # So?  What about this header?
9611 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9612 <  yes:no: )
9613 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5
9614 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9615 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&5
9616 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&2;}
9617 <    ac_header_preproc=yes
9618 <    ;;
9619 <  no:yes:* )
9620 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&5
9621 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&2;}
9622 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&5
9623 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&2;}
9624 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&5
9625 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&2;}
9626 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&5
9627 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9628 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&5
9629 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&2;}
9630 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&5
9631 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&2;}
9632 <    ( cat <<\_ASBOX
9633 < ## ------------------------------ ##
9634 < ## Report this to gezelter@nd.edu ##
9635 < ## ------------------------------ ##
9636 < _ASBOX
9637 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9638 <    ;;
9639 < esac
9640 < { $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9641 < $as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9642 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9643 <  $as_echo_n "(cached) " >&6
9644 < else
9645 <  ac_cv_header_openbabel_babelconfig_h=$ac_header_preproc
9646 < fi
9647 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9648 < $as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9649 <
9650 < fi
9651 < if test $ac_cv_header_openbabel_babelconfig_h = yes; then
6025 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/babelconfig.h" "ac_cv_header_openbabel_babelconfig_h" "$ac_includes_default"
6026 > if test "x$ac_cv_header_openbabel_babelconfig_h" = xyes; then :
6027    openbabel_cv_openbabel_h=yes
6028   else
6029    openbabel_cv_openbabel_h=no
6030   fi
6031  
6032  
6033 <        if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
6034 <  { $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9660 < $as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9661 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9662 <  $as_echo_n "(cached) " >&6
9663 < fi
9664 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9665 < $as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9666 < else
9667 <  # Is the header compilable?
9668 < { $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h usability" >&5
9669 < $as_echo_n "checking openbabel/obconversion.h usability... " >&6; }
9670 < cat >conftest.$ac_ext <<_ACEOF
9671 < /* confdefs.h.  */
9672 < _ACEOF
9673 < cat confdefs.h >>conftest.$ac_ext
9674 < cat >>conftest.$ac_ext <<_ACEOF
9675 < /* end confdefs.h.  */
9676 < $ac_includes_default
9677 < #include <openbabel/obconversion.h>
9678 < _ACEOF
9679 < rm -f conftest.$ac_objext
9680 < if { (ac_try="$ac_compile"
9681 < case "(($ac_try" in
9682 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9683 <  *) ac_try_echo=$ac_try;;
9684 < esac
9685 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9686 < $as_echo "$ac_try_echo") >&5
9687 <  (eval "$ac_compile") 2>conftest.er1
9688 <  ac_status=$?
9689 <  grep -v '^ *+' conftest.er1 >conftest.err
9690 <  rm -f conftest.er1
9691 <  cat conftest.err >&5
9692 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9693 <  (exit $ac_status); } && {
9694 <         test -z "$ac_cxx_werror_flag" ||
9695 <         test ! -s conftest.err
9696 <       } && test -s conftest.$ac_objext; then
9697 <  ac_header_compiler=yes
9698 < else
9699 <  $as_echo "$as_me: failed program was:" >&5
9700 < sed 's/^/| /' conftest.$ac_ext >&5
9701 <
9702 <        ac_header_compiler=no
9703 < fi
9704 <
9705 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9706 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9707 < $as_echo "$ac_header_compiler" >&6; }
9708 <
9709 < # Is the header present?
9710 < { $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h presence" >&5
9711 < $as_echo_n "checking openbabel/obconversion.h presence... " >&6; }
9712 < cat >conftest.$ac_ext <<_ACEOF
9713 < /* confdefs.h.  */
9714 < _ACEOF
9715 < cat confdefs.h >>conftest.$ac_ext
9716 < cat >>conftest.$ac_ext <<_ACEOF
9717 < /* end confdefs.h.  */
9718 < #include <openbabel/obconversion.h>
9719 < _ACEOF
9720 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9721 < case "(($ac_try" in
9722 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9723 <  *) ac_try_echo=$ac_try;;
9724 < esac
9725 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9726 < $as_echo "$ac_try_echo") >&5
9727 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9728 <  ac_status=$?
9729 <  grep -v '^ *+' conftest.er1 >conftest.err
9730 <  rm -f conftest.er1
9731 <  cat conftest.err >&5
9732 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9733 <  (exit $ac_status); } >/dev/null && {
9734 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9735 <         test ! -s conftest.err
9736 <       }; then
9737 <  ac_header_preproc=yes
9738 < else
9739 <  $as_echo "$as_me: failed program was:" >&5
9740 < sed 's/^/| /' conftest.$ac_ext >&5
9741 <
9742 <  ac_header_preproc=no
9743 < fi
9744 <
9745 < rm -f conftest.err conftest.$ac_ext
9746 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9747 < $as_echo "$ac_header_preproc" >&6; }
9748 <
9749 < # So?  What about this header?
9750 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9751 <  yes:no: )
9752 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&5
9753 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9754 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&5
9755 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&2;}
9756 <    ac_header_preproc=yes
9757 <    ;;
9758 <  no:yes:* )
9759 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&5
9760 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&2;}
9761 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&5
9762 < $as_echo "$as_me: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&2;}
9763 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&5
9764 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&2;}
9765 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&5
9766 < $as_echo "$as_me: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9767 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&5
9768 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&2;}
9769 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&5
9770 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&2;}
9771 <    ( cat <<\_ASBOX
9772 < ## ------------------------------ ##
9773 < ## Report this to gezelter@nd.edu ##
9774 < ## ------------------------------ ##
9775 < _ASBOX
9776 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9777 <    ;;
9778 < esac
9779 < { $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9780 < $as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9781 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9782 <  $as_echo_n "(cached) " >&6
9783 < else
9784 <  ac_cv_header_openbabel_obconversion_h=$ac_header_preproc
9785 < fi
9786 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9787 < $as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9788 <
9789 < fi
9790 < if test $ac_cv_header_openbabel_obconversion_h = yes; then
6033 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/obconversion.h" "ac_cv_header_openbabel_obconversion_h" "$ac_includes_default"
6034 > if test "x$ac_cv_header_openbabel_obconversion_h" = xyes; then :
6035    openbabel_cv_obconversion_h=yes
6036   else
6037    openbabel_cv_obconversion_h=no
6038   fi
6039  
6040  
6041 <        cat >conftest.$ac_ext <<_ACEOF
9798 <
9799 <             /* confdefs.h.  */
9800 < _ACEOF
9801 < cat confdefs.h >>conftest.$ac_ext
9802 < cat >>conftest.$ac_ext <<_ACEOF
6041 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6042   /* end confdefs.h.  */
6043  
6044 +
6045   #include <openbabel/babelconfig.h>
6046   #include <openbabel/obconversion.h>
6047   using namespace std;
6048   using namespace OpenBabel;
6049  
9810 – #ifdef FC_DUMMY_MAIN
9811 – #ifndef FC_DUMMY_MAIN_EQ_F77
9812 – #  ifdef __cplusplus
9813 –     extern "C"
9814 – #  endif
9815 –   int FC_DUMMY_MAIN() { return 1; }
9816 – #endif
9817 – #endif
6050   int
6051   main ()
6052   {
# Line 9826 | Line 6058 | _ACEOF
6058    return 0;
6059   }
6060   _ACEOF
6061 < rm -f conftest.$ac_objext conftest$ac_exeext
9830 < if { (ac_try="$ac_link"
9831 < case "(($ac_try" in
9832 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9833 <  *) ac_try_echo=$ac_try;;
9834 < esac
9835 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9836 < $as_echo "$ac_try_echo") >&5
9837 <  (eval "$ac_link") 2>conftest.er1
9838 <  ac_status=$?
9839 <  grep -v '^ *+' conftest.er1 >conftest.err
9840 <  rm -f conftest.er1
9841 <  cat conftest.err >&5
9842 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9843 <  (exit $ac_status); } && {
9844 <         test -z "$ac_cxx_werror_flag" ||
9845 <         test ! -s conftest.err
9846 <       } && test -s conftest$ac_exeext && {
9847 <         test "$cross_compiling" = yes ||
9848 <         $as_test_x conftest$ac_exeext
9849 <       }; then
6061 > if ac_fn_cxx_try_link "$LINENO"; then :
6062  
6063                  openbabel_lib_found="yes"
6064 <                { $as_echo "$as_me:$LINENO: result: found" >&5
6064 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
6065   $as_echo "found" >&6; }
6066  
6067   else
9856 –  $as_echo "$as_me: failed program was:" >&5
9857 – sed 's/^/| /' conftest.$ac_ext >&5
6068  
9859 –
6069                  openbabel_lib_found="no"
6070 <                { $as_echo "$as_me:$LINENO: result: not found" >&5
6070 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6071   $as_echo "not found" >&6; }
6072  
6073  
6074   fi
6075 <
6076 < rm -rf conftest.dSYM
9868 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9869 <      conftest$ac_exeext conftest.$ac_ext
6075 > rm -f core conftest.err conftest.$ac_objext \
6076 >    conftest$ac_exeext conftest.$ac_ext
6077          ac_ext=c
6078   ac_cpp='$CPP $CPPFLAGS'
6079   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 9882 | Line 6089 | ac_compiler_gnu=$ac_cv_c_compiler_gnu
6089                  OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
6090                  OPENBABEL_LIB="-lopenbabel"
6091          else
6092 <                { $as_echo "$as_me:$LINENO: checking openbabel in ${OPENBABEL_HOME}" >&5
6092 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking openbabel in ${OPENBABEL_HOME}" >&5
6093   $as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
6094                  OPENBABEL_INC_DIR=
6095                  OPENBABEL_LIB_DIR=
6096                  OPENBABEL_LIB=
6097                  USE_OPENBABEL=no
6098 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
6098 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
6099   $as_echo "failed" >&6; }
6100                  echo ""
6101                  echo "*********************************************************"
6102                  echo "* WARNING: Could not find a working openbabel-2.x       *"
6103 <                echo "* installation If you need OOPSE to be able to convert  *"
6103 >                echo "* installation If you need OpenMD to be able to convert *"
6104                  echo "* xyz or pdb files you need to specify a valid          *"
6105                  echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
6106                  echo "*                                                       *"
6107 <                echo "* OOPSE will still work without openbabel installed.    *"
6107 >                echo "* OpenMD will still work without openbabel installed.   *"
6108                  echo "*********************************************************"
6109                  echo ""
6110          fi
# Line 9910 | Line 6117 | fi
6117  
6118  
6119   # Checks for header files.
6120 < { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
6120 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
6121   $as_echo_n "checking for ANSI C header files... " >&6; }
6122 < if test "${ac_cv_header_stdc+set}" = set; then
6122 > if ${ac_cv_header_stdc+:} false; then :
6123    $as_echo_n "(cached) " >&6
6124   else
6125 <  cat >conftest.$ac_ext <<_ACEOF
9919 < /* confdefs.h.  */
9920 < _ACEOF
9921 < cat confdefs.h >>conftest.$ac_ext
9922 < cat >>conftest.$ac_ext <<_ACEOF
6125 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6126   /* end confdefs.h.  */
6127   #include <stdlib.h>
6128   #include <stdarg.h>
6129   #include <string.h>
6130   #include <float.h>
6131  
9929 – #ifdef FC_DUMMY_MAIN
9930 – #ifndef FC_DUMMY_MAIN_EQ_F77
9931 – #  ifdef __cplusplus
9932 –     extern "C"
9933 – #  endif
9934 –   int FC_DUMMY_MAIN() { return 1; }
9935 – #endif
9936 – #endif
6132   int
6133   main ()
6134   {
# Line 9942 | Line 6137 | _ACEOF
6137    return 0;
6138   }
6139   _ACEOF
6140 < rm -f conftest.$ac_objext
9946 < if { (ac_try="$ac_compile"
9947 < case "(($ac_try" in
9948 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9949 <  *) ac_try_echo=$ac_try;;
9950 < esac
9951 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9952 < $as_echo "$ac_try_echo") >&5
9953 <  (eval "$ac_compile") 2>conftest.er1
9954 <  ac_status=$?
9955 <  grep -v '^ *+' conftest.er1 >conftest.err
9956 <  rm -f conftest.er1
9957 <  cat conftest.err >&5
9958 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9959 <  (exit $ac_status); } && {
9960 <         test -z "$ac_c_werror_flag" ||
9961 <         test ! -s conftest.err
9962 <       } && test -s conftest.$ac_objext; then
6140 > if ac_fn_c_try_compile "$LINENO"; then :
6141    ac_cv_header_stdc=yes
6142   else
6143 <  $as_echo "$as_me: failed program was:" >&5
9966 < sed 's/^/| /' conftest.$ac_ext >&5
9967 <
9968 <        ac_cv_header_stdc=no
6143 >  ac_cv_header_stdc=no
6144   fi
9970 –
6145   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6146  
6147   if test $ac_cv_header_stdc = yes; then
6148    # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6149 <  cat >conftest.$ac_ext <<_ACEOF
9976 < /* confdefs.h.  */
9977 < _ACEOF
9978 < cat confdefs.h >>conftest.$ac_ext
9979 < cat >>conftest.$ac_ext <<_ACEOF
6149 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6150   /* end confdefs.h.  */
6151   #include <string.h>
6152  
6153   _ACEOF
6154   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6155 <  $EGREP "memchr" >/dev/null 2>&1; then
6156 <  :
6155 >  $EGREP "memchr" >/dev/null 2>&1; then :
6156 >
6157   else
6158    ac_cv_header_stdc=no
6159   fi
# Line 9993 | Line 6163 | if test $ac_cv_header_stdc = yes; then
6163  
6164   if test $ac_cv_header_stdc = yes; then
6165    # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6166 <  cat >conftest.$ac_ext <<_ACEOF
9997 < /* confdefs.h.  */
9998 < _ACEOF
9999 < cat confdefs.h >>conftest.$ac_ext
10000 < cat >>conftest.$ac_ext <<_ACEOF
6166 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6167   /* end confdefs.h.  */
6168   #include <stdlib.h>
6169  
6170   _ACEOF
6171   if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6172 <  $EGREP "free" >/dev/null 2>&1; then
6173 <  :
6172 >  $EGREP "free" >/dev/null 2>&1; then :
6173 >
6174   else
6175    ac_cv_header_stdc=no
6176   fi
# Line 10014 | Line 6180 | if test $ac_cv_header_stdc = yes; then
6180  
6181   if test $ac_cv_header_stdc = yes; then
6182    # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6183 <  if test "$cross_compiling" = yes; then
6183 >  if test "$cross_compiling" = yes; then :
6184    :
6185   else
6186 <  cat >conftest.$ac_ext <<_ACEOF
10021 < /* confdefs.h.  */
10022 < _ACEOF
10023 < cat confdefs.h >>conftest.$ac_ext
10024 < cat >>conftest.$ac_ext <<_ACEOF
6186 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6187   /* end confdefs.h.  */
6188   #include <ctype.h>
6189   #include <stdlib.h>
# Line 10048 | Line 6210 | _ACEOF
6210    return 0;
6211   }
6212   _ACEOF
6213 < rm -f conftest$ac_exeext
10052 < if { (ac_try="$ac_link"
10053 < case "(($ac_try" in
10054 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10055 <  *) ac_try_echo=$ac_try;;
10056 < esac
10057 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10058 < $as_echo "$ac_try_echo") >&5
10059 <  (eval "$ac_link") 2>&5
10060 <  ac_status=$?
10061 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10062 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10063 <  { (case "(($ac_try" in
10064 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10065 <  *) ac_try_echo=$ac_try;;
10066 < esac
10067 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10068 < $as_echo "$ac_try_echo") >&5
10069 <  (eval "$ac_try") 2>&5
10070 <  ac_status=$?
10071 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10072 <  (exit $ac_status); }; }; then
10073 <  :
10074 < else
10075 <  $as_echo "$as_me: program exited with status $ac_status" >&5
10076 < $as_echo "$as_me: failed program was:" >&5
10077 < sed 's/^/| /' conftest.$ac_ext >&5
6213 > if ac_fn_c_try_run "$LINENO"; then :
6214  
6215 < ( exit $ac_status )
6216 < ac_cv_header_stdc=no
6215 > else
6216 >  ac_cv_header_stdc=no
6217   fi
6218 < rm -rf conftest.dSYM
6219 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6218 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6219 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6220   fi
6221  
10086 –
6222   fi
6223   fi
6224 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6224 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
6225   $as_echo "$ac_cv_header_stdc" >&6; }
6226   if test $ac_cv_header_stdc = yes; then
6227  
6228 < cat >>confdefs.h <<\_ACEOF
10094 < #define STDC_HEADERS 1
10095 < _ACEOF
6228 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
6229  
6230   fi
6231  
10099 –
10100 –
10101 –
10102 –
10103 –
10104 –
10105 –
10106 –
10107 –
10108 –
10109 –
10110 –
10111 –
10112 –
10113 –
6232   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
6233 < do
6234 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6235 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
6236 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10119 < $as_echo_n "checking for $ac_header... " >&6; }
10120 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10121 <  $as_echo_n "(cached) " >&6
10122 < fi
10123 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10124 <                 $as_echo "$as_val"'`
10125 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10126 < $as_echo "$ac_res" >&6; }
10127 < else
10128 <  # Is the header compilable?
10129 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10130 < $as_echo_n "checking $ac_header usability... " >&6; }
10131 < cat >conftest.$ac_ext <<_ACEOF
10132 < /* confdefs.h.  */
10133 < _ACEOF
10134 < cat confdefs.h >>conftest.$ac_ext
10135 < cat >>conftest.$ac_ext <<_ACEOF
10136 < /* end confdefs.h.  */
10137 < $ac_includes_default
10138 < #include <$ac_header>
10139 < _ACEOF
10140 < rm -f conftest.$ac_objext
10141 < if { (ac_try="$ac_compile"
10142 < case "(($ac_try" in
10143 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10144 <  *) ac_try_echo=$ac_try;;
10145 < esac
10146 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10147 < $as_echo "$ac_try_echo") >&5
10148 <  (eval "$ac_compile") 2>conftest.er1
10149 <  ac_status=$?
10150 <  grep -v '^ *+' conftest.er1 >conftest.err
10151 <  rm -f conftest.er1
10152 <  cat conftest.err >&5
10153 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10154 <  (exit $ac_status); } && {
10155 <         test -z "$ac_c_werror_flag" ||
10156 <         test ! -s conftest.err
10157 <       } && test -s conftest.$ac_objext; then
10158 <  ac_header_compiler=yes
10159 < else
10160 <  $as_echo "$as_me: failed program was:" >&5
10161 < sed 's/^/| /' conftest.$ac_ext >&5
10162 <
10163 <        ac_header_compiler=no
10164 < fi
10165 <
10166 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10167 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10168 < $as_echo "$ac_header_compiler" >&6; }
10169 <
10170 < # Is the header present?
10171 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10172 < $as_echo_n "checking $ac_header presence... " >&6; }
10173 < cat >conftest.$ac_ext <<_ACEOF
10174 < /* confdefs.h.  */
10175 < _ACEOF
10176 < cat confdefs.h >>conftest.$ac_ext
10177 < cat >>conftest.$ac_ext <<_ACEOF
10178 < /* end confdefs.h.  */
10179 < #include <$ac_header>
10180 < _ACEOF
10181 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10182 < case "(($ac_try" in
10183 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10184 <  *) ac_try_echo=$ac_try;;
10185 < esac
10186 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10187 < $as_echo "$ac_try_echo") >&5
10188 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10189 <  ac_status=$?
10190 <  grep -v '^ *+' conftest.er1 >conftest.err
10191 <  rm -f conftest.er1
10192 <  cat conftest.err >&5
10193 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10194 <  (exit $ac_status); } >/dev/null && {
10195 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10196 <         test ! -s conftest.err
10197 <       }; then
10198 <  ac_header_preproc=yes
10199 < else
10200 <  $as_echo "$as_me: failed program was:" >&5
10201 < sed 's/^/| /' conftest.$ac_ext >&5
10202 <
10203 <  ac_header_preproc=no
10204 < fi
10205 <
10206 < rm -f conftest.err conftest.$ac_ext
10207 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10208 < $as_echo "$ac_header_preproc" >&6; }
10209 <
10210 < # So?  What about this header?
10211 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10212 <  yes:no: )
10213 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10214 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10215 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10216 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10217 <    ac_header_preproc=yes
10218 <    ;;
10219 <  no:yes:* )
10220 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10221 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10222 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10223 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10224 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10225 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10226 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10227 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10228 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10229 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10230 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10231 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10232 <    ( cat <<\_ASBOX
10233 < ## ------------------------------ ##
10234 < ## Report this to gezelter@nd.edu ##
10235 < ## ------------------------------ ##
10236 < _ASBOX
10237 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10238 <    ;;
10239 < esac
10240 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10241 < $as_echo_n "checking for $ac_header... " >&6; }
10242 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10243 <  $as_echo_n "(cached) " >&6
10244 < else
10245 <  eval "$as_ac_Header=\$ac_header_preproc"
10246 < fi
10247 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10248 <                 $as_echo "$as_val"'`
10249 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10250 < $as_echo "$ac_res" >&6; }
10251 <
10252 < fi
10253 < if test `eval 'as_val=${'$as_ac_Header'}
10254 <                 $as_echo "$as_val"'` = yes; then
6233 > do :
6234 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6235 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
6236 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
6237    cat >>confdefs.h <<_ACEOF
6238   #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6239   _ACEOF
# Line 10262 | Line 6244 | done
6244  
6245  
6246   # Checks for typedefs, structures, and compiler characteristics.
6247 < { $as_echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
6247 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
6248   $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
6249 < if test "${ac_cv_header_stdbool_h+set}" = set; then
6249 > if ${ac_cv_header_stdbool_h+:} false; then :
6250    $as_echo_n "(cached) " >&6
6251   else
6252 <  cat >conftest.$ac_ext <<_ACEOF
10271 < /* confdefs.h.  */
10272 < _ACEOF
10273 < cat confdefs.h >>conftest.$ac_ext
10274 < cat >>conftest.$ac_ext <<_ACEOF
6252 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6253   /* end confdefs.h.  */
6254  
6255   #include <stdbool.h>
# Line 10300 | Line 6278 | cat >>conftest.$ac_ext <<_ACEOF
6278          char b[false == 0 ? 1 : -1];
6279          char c[__bool_true_false_are_defined == 1 ? 1 : -1];
6280          char d[(bool) 0.5 == true ? 1 : -1];
6281 <        bool e = &s;
6281 >        /* See body of main program for 'e'.  */
6282          char f[(_Bool) 0.0 == false ? 1 : -1];
6283          char g[true];
6284          char h[sizeof (_Bool)];
# Line 10311 | Line 6289 | cat >>conftest.$ac_ext <<_ACEOF
6289          _Bool n[m];
6290          char o[sizeof n == m * sizeof n[0] ? 1 : -1];
6291          char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
10314 – #       if defined __xlc__ || defined __GNUC__
10315 –         /* Catch a bug in IBM AIX xlc compiler version 6.0.0.0
10316 –            reported by James Lemley on 2005-10-05; see
10317 –            http://lists.gnu.org/archive/html/bug-coreutils/2005-10/msg00086.html
10318 –            This test is not quite right, since xlc is allowed to
10319 –            reject this program, as the initializer for xlcbug is
10320 –            not one of the forms that C requires support for.
10321 –            However, doing the test right would require a runtime
10322 –            test, and that would make cross-compilation harder.
10323 –            Let us hope that IBM fixes the xlc bug, and also adds
10324 –            support for this kind of constant expression.  In the
10325 –            meantime, this test will reject xlc, which is OK, since
10326 –            our stdbool.h substitute should suffice.  We also test
10327 –            this with GCC, where it should work, to detect more
10328 –            quickly whether someone messes up the test in the
10329 –            future.  */
10330 –         char digs[] = "0123456789";
10331 –         int xlcbug = 1 / (&(digs + 5)[-2 + (bool) 1] == &digs[4] ? 1 : -1);
10332 – #       endif
6292          /* Catch a bug in an HP-UX C compiler.  See
6293             http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
6294             http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
# Line 10337 | Line 6296 | cat >>conftest.$ac_ext <<_ACEOF
6296          _Bool q = true;
6297          _Bool *pq = &q;
6298  
10340 – #ifdef FC_DUMMY_MAIN
10341 – #ifndef FC_DUMMY_MAIN_EQ_F77
10342 – #  ifdef __cplusplus
10343 –     extern "C"
10344 – #  endif
10345 –   int FC_DUMMY_MAIN() { return 1; }
10346 – #endif
10347 – #endif
6299   int
6300   main ()
6301   {
6302  
6303 +        bool e = &s;
6304          *pq |= q;
6305          *pq |= ! q;
6306          /* Refer to every declared value, to avoid compiler optimizations.  */
# Line 10359 | Line 6311 | _ACEOF
6311    return 0;
6312   }
6313   _ACEOF
6314 < rm -f conftest.$ac_objext
10363 < if { (ac_try="$ac_compile"
10364 < case "(($ac_try" in
10365 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10366 <  *) ac_try_echo=$ac_try;;
10367 < esac
10368 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10369 < $as_echo "$ac_try_echo") >&5
10370 <  (eval "$ac_compile") 2>conftest.er1
10371 <  ac_status=$?
10372 <  grep -v '^ *+' conftest.er1 >conftest.err
10373 <  rm -f conftest.er1
10374 <  cat conftest.err >&5
10375 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10376 <  (exit $ac_status); } && {
10377 <         test -z "$ac_c_werror_flag" ||
10378 <         test ! -s conftest.err
10379 <       } && test -s conftest.$ac_objext; then
6314 > if ac_fn_c_try_compile "$LINENO"; then :
6315    ac_cv_header_stdbool_h=yes
6316   else
6317 <  $as_echo "$as_me: failed program was:" >&5
10383 < sed 's/^/| /' conftest.$ac_ext >&5
10384 <
10385 <        ac_cv_header_stdbool_h=no
6317 >  ac_cv_header_stdbool_h=no
6318   fi
10387 –
6319   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6320   fi
6321 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
6321 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
6322   $as_echo "$ac_cv_header_stdbool_h" >&6; }
6323 < { $as_echo "$as_me:$LINENO: checking for _Bool" >&5
6324 < $as_echo_n "checking for _Bool... " >&6; }
10394 < if test "${ac_cv_type__Bool+set}" = set; then
10395 <  $as_echo_n "(cached) " >&6
10396 < else
10397 <  ac_cv_type__Bool=no
10398 < cat >conftest.$ac_ext <<_ACEOF
10399 < /* confdefs.h.  */
10400 < _ACEOF
10401 < cat confdefs.h >>conftest.$ac_ext
10402 < cat >>conftest.$ac_ext <<_ACEOF
10403 < /* end confdefs.h.  */
10404 < $ac_includes_default
10405 < #ifdef FC_DUMMY_MAIN
10406 < #ifndef FC_DUMMY_MAIN_EQ_F77
10407 < #  ifdef __cplusplus
10408 <     extern "C"
10409 < #  endif
10410 <   int FC_DUMMY_MAIN() { return 1; }
10411 < #endif
10412 < #endif
10413 < int
10414 < main ()
10415 < {
10416 < if (sizeof (_Bool))
10417 <       return 0;
10418 <  ;
10419 <  return 0;
10420 < }
10421 < _ACEOF
10422 < rm -f conftest.$ac_objext
10423 < if { (ac_try="$ac_compile"
10424 < case "(($ac_try" in
10425 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10426 <  *) ac_try_echo=$ac_try;;
10427 < esac
10428 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10429 < $as_echo "$ac_try_echo") >&5
10430 <  (eval "$ac_compile") 2>conftest.er1
10431 <  ac_status=$?
10432 <  grep -v '^ *+' conftest.er1 >conftest.err
10433 <  rm -f conftest.er1
10434 <  cat conftest.err >&5
10435 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10436 <  (exit $ac_status); } && {
10437 <         test -z "$ac_c_werror_flag" ||
10438 <         test ! -s conftest.err
10439 <       } && test -s conftest.$ac_objext; then
10440 <  cat >conftest.$ac_ext <<_ACEOF
10441 < /* confdefs.h.  */
10442 < _ACEOF
10443 < cat confdefs.h >>conftest.$ac_ext
10444 < cat >>conftest.$ac_ext <<_ACEOF
10445 < /* end confdefs.h.  */
10446 < $ac_includes_default
10447 < #ifdef FC_DUMMY_MAIN
10448 < #ifndef FC_DUMMY_MAIN_EQ_F77
10449 < #  ifdef __cplusplus
10450 <     extern "C"
10451 < #  endif
10452 <   int FC_DUMMY_MAIN() { return 1; }
10453 < #endif
10454 < #endif
10455 < int
10456 < main ()
10457 < {
10458 < if (sizeof ((_Bool)))
10459 <          return 0;
10460 <  ;
10461 <  return 0;
10462 < }
10463 < _ACEOF
10464 < rm -f conftest.$ac_objext
10465 < if { (ac_try="$ac_compile"
10466 < case "(($ac_try" in
10467 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10468 <  *) ac_try_echo=$ac_try;;
10469 < esac
10470 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10471 < $as_echo "$ac_try_echo") >&5
10472 <  (eval "$ac_compile") 2>conftest.er1
10473 <  ac_status=$?
10474 <  grep -v '^ *+' conftest.er1 >conftest.err
10475 <  rm -f conftest.er1
10476 <  cat conftest.err >&5
10477 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10478 <  (exit $ac_status); } && {
10479 <         test -z "$ac_c_werror_flag" ||
10480 <         test ! -s conftest.err
10481 <       } && test -s conftest.$ac_objext; then
10482 <  :
10483 < else
10484 <  $as_echo "$as_me: failed program was:" >&5
10485 < sed 's/^/| /' conftest.$ac_ext >&5
6323 > ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
6324 > if test "x$ac_cv_type__Bool" = xyes; then :
6325  
10487 –        ac_cv_type__Bool=yes
10488 – fi
10489 –
10490 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10491 – else
10492 –  $as_echo "$as_me: failed program was:" >&5
10493 – sed 's/^/| /' conftest.$ac_ext >&5
10494 –
10495 –
10496 – fi
10497 –
10498 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10499 – fi
10500 – { $as_echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
10501 – $as_echo "$ac_cv_type__Bool" >&6; }
10502 – if test $ac_cv_type__Bool = yes; then
10503 –
6326   cat >>confdefs.h <<_ACEOF
6327   #define HAVE__BOOL 1
6328   _ACEOF
# Line 10510 | Line 6332 | if test $ac_cv_header_stdbool_h = yes; then
6332  
6333   if test $ac_cv_header_stdbool_h = yes; then
6334  
6335 < cat >>confdefs.h <<\_ACEOF
10514 < #define HAVE_STDBOOL_H 1
10515 < _ACEOF
6335 > $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
6336  
6337   fi
6338  
6339 < { $as_echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
6339 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
6340   $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
6341 < if test "${ac_cv_c_const+set}" = set; then
6341 > if ${ac_cv_c_const+:} false; then :
6342    $as_echo_n "(cached) " >&6
6343   else
6344 <  cat >conftest.$ac_ext <<_ACEOF
10525 < /* confdefs.h.  */
10526 < _ACEOF
10527 < cat confdefs.h >>conftest.$ac_ext
10528 < cat >>conftest.$ac_ext <<_ACEOF
6344 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6345   /* end confdefs.h.  */
6346  
10531 – #ifdef FC_DUMMY_MAIN
10532 – #ifndef FC_DUMMY_MAIN_EQ_F77
10533 – #  ifdef __cplusplus
10534 –     extern "C"
10535 – #  endif
10536 –   int FC_DUMMY_MAIN() { return 1; }
10537 – #endif
10538 – #endif
6347   int
6348   main ()
6349   {
# Line 10593 | Line 6401 | _ACEOF
6401    return 0;
6402   }
6403   _ACEOF
6404 < rm -f conftest.$ac_objext
10597 < if { (ac_try="$ac_compile"
10598 < case "(($ac_try" in
10599 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10600 <  *) ac_try_echo=$ac_try;;
10601 < esac
10602 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10603 < $as_echo "$ac_try_echo") >&5
10604 <  (eval "$ac_compile") 2>conftest.er1
10605 <  ac_status=$?
10606 <  grep -v '^ *+' conftest.er1 >conftest.err
10607 <  rm -f conftest.er1
10608 <  cat conftest.err >&5
10609 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10610 <  (exit $ac_status); } && {
10611 <         test -z "$ac_c_werror_flag" ||
10612 <         test ! -s conftest.err
10613 <       } && test -s conftest.$ac_objext; then
6404 > if ac_fn_c_try_compile "$LINENO"; then :
6405    ac_cv_c_const=yes
6406   else
6407 <  $as_echo "$as_me: failed program was:" >&5
10617 < sed 's/^/| /' conftest.$ac_ext >&5
10618 <
10619 <        ac_cv_c_const=no
6407 >  ac_cv_c_const=no
6408   fi
10621 –
6409   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6410   fi
6411 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
6411 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
6412   $as_echo "$ac_cv_c_const" >&6; }
6413   if test $ac_cv_c_const = no; then
6414  
6415 < cat >>confdefs.h <<\_ACEOF
10629 < #define const /**/
10630 < _ACEOF
6415 > $as_echo "#define const /**/" >>confdefs.h
6416  
6417   fi
6418  
6419 < { $as_echo "$as_me:$LINENO: checking for inline" >&5
6419 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
6420   $as_echo_n "checking for inline... " >&6; }
6421 < if test "${ac_cv_c_inline+set}" = set; then
6421 > if ${ac_cv_c_inline+:} false; then :
6422    $as_echo_n "(cached) " >&6
6423   else
6424    ac_cv_c_inline=no
6425   for ac_kw in inline __inline__ __inline; do
6426 <  cat >conftest.$ac_ext <<_ACEOF
10642 < /* confdefs.h.  */
10643 < _ACEOF
10644 < cat confdefs.h >>conftest.$ac_ext
10645 < cat >>conftest.$ac_ext <<_ACEOF
6426 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6427   /* end confdefs.h.  */
6428   #ifndef __cplusplus
6429   typedef int foo_t;
# Line 10651 | Line 6432 | _ACEOF
6432   #endif
6433  
6434   _ACEOF
6435 < rm -f conftest.$ac_objext
10655 < if { (ac_try="$ac_compile"
10656 < case "(($ac_try" in
10657 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10658 <  *) ac_try_echo=$ac_try;;
10659 < esac
10660 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10661 < $as_echo "$ac_try_echo") >&5
10662 <  (eval "$ac_compile") 2>conftest.er1
10663 <  ac_status=$?
10664 <  grep -v '^ *+' conftest.er1 >conftest.err
10665 <  rm -f conftest.er1
10666 <  cat conftest.err >&5
10667 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10668 <  (exit $ac_status); } && {
10669 <         test -z "$ac_c_werror_flag" ||
10670 <         test ! -s conftest.err
10671 <       } && test -s conftest.$ac_objext; then
6435 > if ac_fn_c_try_compile "$LINENO"; then :
6436    ac_cv_c_inline=$ac_kw
10673 – else
10674 –  $as_echo "$as_me: failed program was:" >&5
10675 – sed 's/^/| /' conftest.$ac_ext >&5
10676 –
10677 –
6437   fi
10679 –
6438   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6439    test "$ac_cv_c_inline" != no && break
6440   done
6441  
6442   fi
6443 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
6443 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
6444   $as_echo "$ac_cv_c_inline" >&6; }
6445  
10688 –
6446   case $ac_cv_c_inline in
6447    inline | yes) ;;
6448    *)
# Line 10701 | Line 6458 | esac
6458      ;;
6459   esac
6460  
6461 < { $as_echo "$as_me:$LINENO: checking for size_t" >&5
6462 < $as_echo_n "checking for size_t... " >&6; }
10706 < if test "${ac_cv_type_size_t+set}" = set; then
10707 <  $as_echo_n "(cached) " >&6
10708 < else
10709 <  ac_cv_type_size_t=no
10710 < cat >conftest.$ac_ext <<_ACEOF
10711 < /* confdefs.h.  */
10712 < _ACEOF
10713 < cat confdefs.h >>conftest.$ac_ext
10714 < cat >>conftest.$ac_ext <<_ACEOF
10715 < /* end confdefs.h.  */
10716 < $ac_includes_default
10717 < #ifdef FC_DUMMY_MAIN
10718 < #ifndef FC_DUMMY_MAIN_EQ_F77
10719 < #  ifdef __cplusplus
10720 <     extern "C"
10721 < #  endif
10722 <   int FC_DUMMY_MAIN() { return 1; }
10723 < #endif
10724 < #endif
10725 < int
10726 < main ()
10727 < {
10728 < if (sizeof (size_t))
10729 <       return 0;
10730 <  ;
10731 <  return 0;
10732 < }
10733 < _ACEOF
10734 < rm -f conftest.$ac_objext
10735 < if { (ac_try="$ac_compile"
10736 < case "(($ac_try" in
10737 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10738 <  *) ac_try_echo=$ac_try;;
10739 < esac
10740 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10741 < $as_echo "$ac_try_echo") >&5
10742 <  (eval "$ac_compile") 2>conftest.er1
10743 <  ac_status=$?
10744 <  grep -v '^ *+' conftest.er1 >conftest.err
10745 <  rm -f conftest.er1
10746 <  cat conftest.err >&5
10747 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10748 <  (exit $ac_status); } && {
10749 <         test -z "$ac_c_werror_flag" ||
10750 <         test ! -s conftest.err
10751 <       } && test -s conftest.$ac_objext; then
10752 <  cat >conftest.$ac_ext <<_ACEOF
10753 < /* confdefs.h.  */
10754 < _ACEOF
10755 < cat confdefs.h >>conftest.$ac_ext
10756 < cat >>conftest.$ac_ext <<_ACEOF
10757 < /* end confdefs.h.  */
10758 < $ac_includes_default
10759 < #ifdef FC_DUMMY_MAIN
10760 < #ifndef FC_DUMMY_MAIN_EQ_F77
10761 < #  ifdef __cplusplus
10762 <     extern "C"
10763 < #  endif
10764 <   int FC_DUMMY_MAIN() { return 1; }
10765 < #endif
10766 < #endif
10767 < int
10768 < main ()
10769 < {
10770 < if (sizeof ((size_t)))
10771 <          return 0;
10772 <  ;
10773 <  return 0;
10774 < }
10775 < _ACEOF
10776 < rm -f conftest.$ac_objext
10777 < if { (ac_try="$ac_compile"
10778 < case "(($ac_try" in
10779 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10780 <  *) ac_try_echo=$ac_try;;
10781 < esac
10782 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10783 < $as_echo "$ac_try_echo") >&5
10784 <  (eval "$ac_compile") 2>conftest.er1
10785 <  ac_status=$?
10786 <  grep -v '^ *+' conftest.er1 >conftest.err
10787 <  rm -f conftest.er1
10788 <  cat conftest.err >&5
10789 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10790 <  (exit $ac_status); } && {
10791 <         test -z "$ac_c_werror_flag" ||
10792 <         test ! -s conftest.err
10793 <       } && test -s conftest.$ac_objext; then
10794 <  :
10795 < else
10796 <  $as_echo "$as_me: failed program was:" >&5
10797 < sed 's/^/| /' conftest.$ac_ext >&5
6461 > ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
6462 > if test "x$ac_cv_type_size_t" = xyes; then :
6463  
10799 –        ac_cv_type_size_t=yes
10800 – fi
10801 –
10802 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6464   else
10804 –  $as_echo "$as_me: failed program was:" >&5
10805 – sed 's/^/| /' conftest.$ac_ext >&5
6465  
10807 –
10808 – fi
10809 –
10810 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10811 – fi
10812 – { $as_echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
10813 – $as_echo "$ac_cv_type_size_t" >&6; }
10814 – if test $ac_cv_type_size_t = yes; then
10815 –  :
10816 – else
10817 –
6466   cat >>confdefs.h <<_ACEOF
6467   #define size_t unsigned int
6468   _ACEOF
6469  
6470   fi
6471  
6472 < { $as_echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
6472 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
6473   $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
6474 < if test "${ac_cv_header_time+set}" = set; then
6474 > if ${ac_cv_header_time+:} false; then :
6475    $as_echo_n "(cached) " >&6
6476   else
6477 <  cat >conftest.$ac_ext <<_ACEOF
10830 < /* confdefs.h.  */
10831 < _ACEOF
10832 < cat confdefs.h >>conftest.$ac_ext
10833 < cat >>conftest.$ac_ext <<_ACEOF
6477 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6478   /* end confdefs.h.  */
6479   #include <sys/types.h>
6480   #include <sys/time.h>
6481   #include <time.h>
6482  
10839 – #ifdef FC_DUMMY_MAIN
10840 – #ifndef FC_DUMMY_MAIN_EQ_F77
10841 – #  ifdef __cplusplus
10842 –     extern "C"
10843 – #  endif
10844 –   int FC_DUMMY_MAIN() { return 1; }
10845 – #endif
10846 – #endif
6483   int
6484   main ()
6485   {
# Line 10853 | Line 6489 | _ACEOF
6489    return 0;
6490   }
6491   _ACEOF
6492 < rm -f conftest.$ac_objext
10857 < if { (ac_try="$ac_compile"
10858 < case "(($ac_try" in
10859 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10860 <  *) ac_try_echo=$ac_try;;
10861 < esac
10862 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10863 < $as_echo "$ac_try_echo") >&5
10864 <  (eval "$ac_compile") 2>conftest.er1
10865 <  ac_status=$?
10866 <  grep -v '^ *+' conftest.er1 >conftest.err
10867 <  rm -f conftest.er1
10868 <  cat conftest.err >&5
10869 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10870 <  (exit $ac_status); } && {
10871 <         test -z "$ac_c_werror_flag" ||
10872 <         test ! -s conftest.err
10873 <       } && test -s conftest.$ac_objext; then
6492 > if ac_fn_c_try_compile "$LINENO"; then :
6493    ac_cv_header_time=yes
6494   else
6495 <  $as_echo "$as_me: failed program was:" >&5
10877 < sed 's/^/| /' conftest.$ac_ext >&5
10878 <
10879 <        ac_cv_header_time=no
6495 >  ac_cv_header_time=no
6496   fi
10881 –
6497   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6498   fi
6499 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
6499 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
6500   $as_echo "$ac_cv_header_time" >&6; }
6501   if test $ac_cv_header_time = yes; then
6502  
6503 < cat >>confdefs.h <<\_ACEOF
10889 < #define TIME_WITH_SYS_TIME 1
10890 < _ACEOF
6503 > $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
6504  
6505   fi
6506  
6507  
6508   # Checks for library functions.
10896 –
6509   for ac_header in stdlib.h
6510 < do
6511 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6512 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10901 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10902 < $as_echo_n "checking for $ac_header... " >&6; }
10903 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10904 <  $as_echo_n "(cached) " >&6
10905 < fi
10906 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10907 <                 $as_echo "$as_val"'`
10908 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10909 < $as_echo "$ac_res" >&6; }
10910 < else
10911 <  # Is the header compilable?
10912 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10913 < $as_echo_n "checking $ac_header usability... " >&6; }
10914 < cat >conftest.$ac_ext <<_ACEOF
10915 < /* confdefs.h.  */
10916 < _ACEOF
10917 < cat confdefs.h >>conftest.$ac_ext
10918 < cat >>conftest.$ac_ext <<_ACEOF
10919 < /* end confdefs.h.  */
10920 < $ac_includes_default
10921 < #include <$ac_header>
10922 < _ACEOF
10923 < rm -f conftest.$ac_objext
10924 < if { (ac_try="$ac_compile"
10925 < case "(($ac_try" in
10926 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10927 <  *) ac_try_echo=$ac_try;;
10928 < esac
10929 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10930 < $as_echo "$ac_try_echo") >&5
10931 <  (eval "$ac_compile") 2>conftest.er1
10932 <  ac_status=$?
10933 <  grep -v '^ *+' conftest.er1 >conftest.err
10934 <  rm -f conftest.er1
10935 <  cat conftest.err >&5
10936 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10937 <  (exit $ac_status); } && {
10938 <         test -z "$ac_c_werror_flag" ||
10939 <         test ! -s conftest.err
10940 <       } && test -s conftest.$ac_objext; then
10941 <  ac_header_compiler=yes
10942 < else
10943 <  $as_echo "$as_me: failed program was:" >&5
10944 < sed 's/^/| /' conftest.$ac_ext >&5
10945 <
10946 <        ac_header_compiler=no
10947 < fi
10948 <
10949 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10950 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10951 < $as_echo "$ac_header_compiler" >&6; }
10952 <
10953 < # Is the header present?
10954 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10955 < $as_echo_n "checking $ac_header presence... " >&6; }
10956 < cat >conftest.$ac_ext <<_ACEOF
10957 < /* confdefs.h.  */
10958 < _ACEOF
10959 < cat confdefs.h >>conftest.$ac_ext
10960 < cat >>conftest.$ac_ext <<_ACEOF
10961 < /* end confdefs.h.  */
10962 < #include <$ac_header>
10963 < _ACEOF
10964 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10965 < case "(($ac_try" in
10966 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10967 <  *) ac_try_echo=$ac_try;;
10968 < esac
10969 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10970 < $as_echo "$ac_try_echo") >&5
10971 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10972 <  ac_status=$?
10973 <  grep -v '^ *+' conftest.er1 >conftest.err
10974 <  rm -f conftest.er1
10975 <  cat conftest.err >&5
10976 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10977 <  (exit $ac_status); } >/dev/null && {
10978 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10979 <         test ! -s conftest.err
10980 <       }; then
10981 <  ac_header_preproc=yes
10982 < else
10983 <  $as_echo "$as_me: failed program was:" >&5
10984 < sed 's/^/| /' conftest.$ac_ext >&5
10985 <
10986 <  ac_header_preproc=no
10987 < fi
10988 <
10989 < rm -f conftest.err conftest.$ac_ext
10990 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10991 < $as_echo "$ac_header_preproc" >&6; }
10992 <
10993 < # So?  What about this header?
10994 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10995 <  yes:no: )
10996 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10997 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10998 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10999 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11000 <    ac_header_preproc=yes
11001 <    ;;
11002 <  no:yes:* )
11003 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11004 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11005 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11006 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11007 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11008 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11009 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11010 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11011 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11012 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11013 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11014 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11015 <    ( cat <<\_ASBOX
11016 < ## ------------------------------ ##
11017 < ## Report this to gezelter@nd.edu ##
11018 < ## ------------------------------ ##
11019 < _ASBOX
11020 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11021 <    ;;
11022 < esac
11023 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11024 < $as_echo_n "checking for $ac_header... " >&6; }
11025 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11026 <  $as_echo_n "(cached) " >&6
11027 < else
11028 <  eval "$as_ac_Header=\$ac_header_preproc"
11029 < fi
11030 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11031 <                 $as_echo "$as_val"'`
11032 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11033 < $as_echo "$ac_res" >&6; }
11034 <
11035 < fi
11036 < if test `eval 'as_val=${'$as_ac_Header'}
11037 <                 $as_echo "$as_val"'` = yes; then
6510 > do :
6511 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6512 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6513    cat >>confdefs.h <<_ACEOF
6514 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6514 > #define HAVE_STDLIB_H 1
6515   _ACEOF
6516  
6517   fi
6518  
6519   done
6520  
6521 < { $as_echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
6521 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
6522   $as_echo_n "checking for GNU libc compatible malloc... " >&6; }
6523 < if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
6523 > if ${ac_cv_func_malloc_0_nonnull+:} false; then :
6524    $as_echo_n "(cached) " >&6
6525   else
6526 <  if test "$cross_compiling" = yes; then
6526 >  if test "$cross_compiling" = yes; then :
6527    ac_cv_func_malloc_0_nonnull=no
6528   else
6529 <  cat >conftest.$ac_ext <<_ACEOF
11055 < /* confdefs.h.  */
11056 < _ACEOF
11057 < cat confdefs.h >>conftest.$ac_ext
11058 < cat >>conftest.$ac_ext <<_ACEOF
6529 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6530   /* end confdefs.h.  */
6531   #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6532   # include <stdlib.h>
# Line 11063 | Line 6534 | char *malloc ();
6534   char *malloc ();
6535   #endif
6536  
11066 – #ifdef FC_DUMMY_MAIN
11067 – #ifndef FC_DUMMY_MAIN_EQ_F77
11068 – #  ifdef __cplusplus
11069 –     extern "C"
11070 – #  endif
11071 –   int FC_DUMMY_MAIN() { return 1; }
11072 – #endif
11073 – #endif
6537   int
6538   main ()
6539   {
# Line 11079 | Line 6542 | _ACEOF
6542    return 0;
6543   }
6544   _ACEOF
6545 < rm -f conftest$ac_exeext
11083 < if { (ac_try="$ac_link"
11084 < case "(($ac_try" in
11085 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11086 <  *) ac_try_echo=$ac_try;;
11087 < esac
11088 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11089 < $as_echo "$ac_try_echo") >&5
11090 <  (eval "$ac_link") 2>&5
11091 <  ac_status=$?
11092 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11093 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11094 <  { (case "(($ac_try" in
11095 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11096 <  *) ac_try_echo=$ac_try;;
11097 < esac
11098 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11099 < $as_echo "$ac_try_echo") >&5
11100 <  (eval "$ac_try") 2>&5
11101 <  ac_status=$?
11102 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11103 <  (exit $ac_status); }; }; then
6545 > if ac_fn_c_try_run "$LINENO"; then :
6546    ac_cv_func_malloc_0_nonnull=yes
6547   else
6548 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11107 < $as_echo "$as_me: failed program was:" >&5
11108 < sed 's/^/| /' conftest.$ac_ext >&5
11109 <
11110 < ( exit $ac_status )
11111 < ac_cv_func_malloc_0_nonnull=no
6548 >  ac_cv_func_malloc_0_nonnull=no
6549   fi
6550 < rm -rf conftest.dSYM
6551 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6550 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6551 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6552   fi
6553  
11117 –
6554   fi
6555 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
6555 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
6556   $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
6557 < if test $ac_cv_func_malloc_0_nonnull = yes; then
6557 > if test $ac_cv_func_malloc_0_nonnull = yes; then :
6558  
6559 < cat >>confdefs.h <<\_ACEOF
11124 < #define HAVE_MALLOC 1
11125 < _ACEOF
6559 > $as_echo "#define HAVE_MALLOC 1" >>confdefs.h
6560  
6561   else
6562 <  cat >>confdefs.h <<\_ACEOF
11129 < #define HAVE_MALLOC 0
11130 < _ACEOF
6562 >  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
6563  
6564     case " $LIBOBJS " in
6565    *" malloc.$ac_objext "* ) ;;
# Line 11136 | Line 6568 | esac
6568   esac
6569  
6570  
6571 < cat >>confdefs.h <<\_ACEOF
11140 < #define malloc rpl_malloc
11141 < _ACEOF
6571 > $as_echo "#define malloc rpl_malloc" >>confdefs.h
6572  
6573   fi
6574  
6575  
11146 –
11147 –
6576   for ac_header in stdlib.h
6577 < do
6578 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6579 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11152 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11153 < $as_echo_n "checking for $ac_header... " >&6; }
11154 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11155 <  $as_echo_n "(cached) " >&6
11156 < fi
11157 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11158 <                 $as_echo "$as_val"'`
11159 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11160 < $as_echo "$ac_res" >&6; }
11161 < else
11162 <  # Is the header compilable?
11163 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11164 < $as_echo_n "checking $ac_header usability... " >&6; }
11165 < cat >conftest.$ac_ext <<_ACEOF
11166 < /* confdefs.h.  */
11167 < _ACEOF
11168 < cat confdefs.h >>conftest.$ac_ext
11169 < cat >>conftest.$ac_ext <<_ACEOF
11170 < /* end confdefs.h.  */
11171 < $ac_includes_default
11172 < #include <$ac_header>
11173 < _ACEOF
11174 < rm -f conftest.$ac_objext
11175 < if { (ac_try="$ac_compile"
11176 < case "(($ac_try" in
11177 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11178 <  *) ac_try_echo=$ac_try;;
11179 < esac
11180 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11181 < $as_echo "$ac_try_echo") >&5
11182 <  (eval "$ac_compile") 2>conftest.er1
11183 <  ac_status=$?
11184 <  grep -v '^ *+' conftest.er1 >conftest.err
11185 <  rm -f conftest.er1
11186 <  cat conftest.err >&5
11187 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11188 <  (exit $ac_status); } && {
11189 <         test -z "$ac_c_werror_flag" ||
11190 <         test ! -s conftest.err
11191 <       } && test -s conftest.$ac_objext; then
11192 <  ac_header_compiler=yes
11193 < else
11194 <  $as_echo "$as_me: failed program was:" >&5
11195 < sed 's/^/| /' conftest.$ac_ext >&5
11196 <
11197 <        ac_header_compiler=no
11198 < fi
11199 <
11200 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11201 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11202 < $as_echo "$ac_header_compiler" >&6; }
11203 <
11204 < # Is the header present?
11205 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11206 < $as_echo_n "checking $ac_header presence... " >&6; }
11207 < cat >conftest.$ac_ext <<_ACEOF
11208 < /* confdefs.h.  */
11209 < _ACEOF
11210 < cat confdefs.h >>conftest.$ac_ext
11211 < cat >>conftest.$ac_ext <<_ACEOF
11212 < /* end confdefs.h.  */
11213 < #include <$ac_header>
11214 < _ACEOF
11215 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11216 < case "(($ac_try" in
11217 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11218 <  *) ac_try_echo=$ac_try;;
11219 < esac
11220 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11221 < $as_echo "$ac_try_echo") >&5
11222 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11223 <  ac_status=$?
11224 <  grep -v '^ *+' conftest.er1 >conftest.err
11225 <  rm -f conftest.er1
11226 <  cat conftest.err >&5
11227 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11228 <  (exit $ac_status); } >/dev/null && {
11229 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11230 <         test ! -s conftest.err
11231 <       }; then
11232 <  ac_header_preproc=yes
11233 < else
11234 <  $as_echo "$as_me: failed program was:" >&5
11235 < sed 's/^/| /' conftest.$ac_ext >&5
11236 <
11237 <  ac_header_preproc=no
11238 < fi
11239 <
11240 < rm -f conftest.err conftest.$ac_ext
11241 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11242 < $as_echo "$ac_header_preproc" >&6; }
11243 <
11244 < # So?  What about this header?
11245 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11246 <  yes:no: )
11247 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11248 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11249 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11250 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11251 <    ac_header_preproc=yes
11252 <    ;;
11253 <  no:yes:* )
11254 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11255 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11256 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11257 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11258 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11259 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11260 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11261 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11262 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11263 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11264 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11265 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11266 <    ( cat <<\_ASBOX
11267 < ## ------------------------------ ##
11268 < ## Report this to gezelter@nd.edu ##
11269 < ## ------------------------------ ##
11270 < _ASBOX
11271 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11272 <    ;;
11273 < esac
11274 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11275 < $as_echo_n "checking for $ac_header... " >&6; }
11276 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11277 <  $as_echo_n "(cached) " >&6
11278 < else
11279 <  eval "$as_ac_Header=\$ac_header_preproc"
11280 < fi
11281 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11282 <                 $as_echo "$as_val"'`
11283 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11284 < $as_echo "$ac_res" >&6; }
11285 <
11286 < fi
11287 < if test `eval 'as_val=${'$as_ac_Header'}
11288 <                 $as_echo "$as_val"'` = yes; then
6577 > do :
6578 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6579 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6580    cat >>confdefs.h <<_ACEOF
6581 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6581 > #define HAVE_STDLIB_H 1
6582   _ACEOF
6583  
6584   fi
6585  
6586   done
6587  
6588 < { $as_echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
6588 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
6589   $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
6590 < if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
6590 > if ${ac_cv_func_realloc_0_nonnull+:} false; then :
6591    $as_echo_n "(cached) " >&6
6592   else
6593 <  if test "$cross_compiling" = yes; then
6593 >  if test "$cross_compiling" = yes; then :
6594    ac_cv_func_realloc_0_nonnull=no
6595   else
6596 <  cat >conftest.$ac_ext <<_ACEOF
11306 < /* confdefs.h.  */
11307 < _ACEOF
11308 < cat confdefs.h >>conftest.$ac_ext
11309 < cat >>conftest.$ac_ext <<_ACEOF
6596 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6597   /* end confdefs.h.  */
6598   #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6599   # include <stdlib.h>
# Line 11314 | Line 6601 | char *realloc ();
6601   char *realloc ();
6602   #endif
6603  
11317 – #ifdef FC_DUMMY_MAIN
11318 – #ifndef FC_DUMMY_MAIN_EQ_F77
11319 – #  ifdef __cplusplus
11320 –     extern "C"
11321 – #  endif
11322 –   int FC_DUMMY_MAIN() { return 1; }
11323 – #endif
11324 – #endif
6604   int
6605   main ()
6606   {
# Line 11330 | Line 6609 | _ACEOF
6609    return 0;
6610   }
6611   _ACEOF
6612 < rm -f conftest$ac_exeext
11334 < if { (ac_try="$ac_link"
11335 < case "(($ac_try" in
11336 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11337 <  *) ac_try_echo=$ac_try;;
11338 < esac
11339 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11340 < $as_echo "$ac_try_echo") >&5
11341 <  (eval "$ac_link") 2>&5
11342 <  ac_status=$?
11343 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11344 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11345 <  { (case "(($ac_try" in
11346 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11347 <  *) ac_try_echo=$ac_try;;
11348 < esac
11349 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11350 < $as_echo "$ac_try_echo") >&5
11351 <  (eval "$ac_try") 2>&5
11352 <  ac_status=$?
11353 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11354 <  (exit $ac_status); }; }; then
6612 > if ac_fn_c_try_run "$LINENO"; then :
6613    ac_cv_func_realloc_0_nonnull=yes
6614   else
6615 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11358 < $as_echo "$as_me: failed program was:" >&5
11359 < sed 's/^/| /' conftest.$ac_ext >&5
11360 <
11361 < ( exit $ac_status )
11362 < ac_cv_func_realloc_0_nonnull=no
6615 >  ac_cv_func_realloc_0_nonnull=no
6616   fi
6617 < rm -rf conftest.dSYM
6618 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6617 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6618 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6619   fi
6620  
11368 –
6621   fi
6622 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
6622 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
6623   $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
6624 < if test $ac_cv_func_realloc_0_nonnull = yes; then
6624 > if test $ac_cv_func_realloc_0_nonnull = yes; then :
6625  
6626 < cat >>confdefs.h <<\_ACEOF
11375 < #define HAVE_REALLOC 1
11376 < _ACEOF
6626 > $as_echo "#define HAVE_REALLOC 1" >>confdefs.h
6627  
6628   else
6629 <  cat >>confdefs.h <<\_ACEOF
11380 < #define HAVE_REALLOC 0
11381 < _ACEOF
6629 >  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
6630  
6631     case " $LIBOBJS " in
6632    *" realloc.$ac_objext "* ) ;;
# Line 11387 | Line 6635 | esac
6635   esac
6636  
6637  
6638 < cat >>confdefs.h <<\_ACEOF
11391 < #define realloc rpl_realloc
11392 < _ACEOF
6638 > $as_echo "#define realloc rpl_realloc" >>confdefs.h
6639  
6640   fi
6641  
6642  
11397 –
11398 –
11399 –
6643   for ac_header in sys/select.h sys/socket.h
6644 < do
6645 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6646 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
6647 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11405 < $as_echo_n "checking for $ac_header... " >&6; }
11406 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11407 <  $as_echo_n "(cached) " >&6
11408 < fi
11409 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11410 <                 $as_echo "$as_val"'`
11411 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11412 < $as_echo "$ac_res" >&6; }
11413 < else
11414 <  # Is the header compilable?
11415 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11416 < $as_echo_n "checking $ac_header usability... " >&6; }
11417 < cat >conftest.$ac_ext <<_ACEOF
11418 < /* confdefs.h.  */
11419 < _ACEOF
11420 < cat confdefs.h >>conftest.$ac_ext
11421 < cat >>conftest.$ac_ext <<_ACEOF
11422 < /* end confdefs.h.  */
11423 < $ac_includes_default
11424 < #include <$ac_header>
11425 < _ACEOF
11426 < rm -f conftest.$ac_objext
11427 < if { (ac_try="$ac_compile"
11428 < case "(($ac_try" in
11429 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11430 <  *) ac_try_echo=$ac_try;;
11431 < esac
11432 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11433 < $as_echo "$ac_try_echo") >&5
11434 <  (eval "$ac_compile") 2>conftest.er1
11435 <  ac_status=$?
11436 <  grep -v '^ *+' conftest.er1 >conftest.err
11437 <  rm -f conftest.er1
11438 <  cat conftest.err >&5
11439 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11440 <  (exit $ac_status); } && {
11441 <         test -z "$ac_c_werror_flag" ||
11442 <         test ! -s conftest.err
11443 <       } && test -s conftest.$ac_objext; then
11444 <  ac_header_compiler=yes
11445 < else
11446 <  $as_echo "$as_me: failed program was:" >&5
11447 < sed 's/^/| /' conftest.$ac_ext >&5
11448 <
11449 <        ac_header_compiler=no
11450 < fi
11451 <
11452 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11453 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11454 < $as_echo "$ac_header_compiler" >&6; }
11455 <
11456 < # Is the header present?
11457 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11458 < $as_echo_n "checking $ac_header presence... " >&6; }
11459 < cat >conftest.$ac_ext <<_ACEOF
11460 < /* confdefs.h.  */
11461 < _ACEOF
11462 < cat confdefs.h >>conftest.$ac_ext
11463 < cat >>conftest.$ac_ext <<_ACEOF
11464 < /* end confdefs.h.  */
11465 < #include <$ac_header>
11466 < _ACEOF
11467 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11468 < case "(($ac_try" in
11469 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11470 <  *) ac_try_echo=$ac_try;;
11471 < esac
11472 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11473 < $as_echo "$ac_try_echo") >&5
11474 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11475 <  ac_status=$?
11476 <  grep -v '^ *+' conftest.er1 >conftest.err
11477 <  rm -f conftest.er1
11478 <  cat conftest.err >&5
11479 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11480 <  (exit $ac_status); } >/dev/null && {
11481 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11482 <         test ! -s conftest.err
11483 <       }; then
11484 <  ac_header_preproc=yes
11485 < else
11486 <  $as_echo "$as_me: failed program was:" >&5
11487 < sed 's/^/| /' conftest.$ac_ext >&5
11488 <
11489 <  ac_header_preproc=no
11490 < fi
11491 <
11492 < rm -f conftest.err conftest.$ac_ext
11493 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11494 < $as_echo "$ac_header_preproc" >&6; }
11495 <
11496 < # So?  What about this header?
11497 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11498 <  yes:no: )
11499 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11500 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11501 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11502 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11503 <    ac_header_preproc=yes
11504 <    ;;
11505 <  no:yes:* )
11506 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11507 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11508 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11509 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11510 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11511 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11512 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11513 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11514 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11515 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11516 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11517 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11518 <    ( cat <<\_ASBOX
11519 < ## ------------------------------ ##
11520 < ## Report this to gezelter@nd.edu ##
11521 < ## ------------------------------ ##
11522 < _ASBOX
11523 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11524 <    ;;
11525 < esac
11526 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11527 < $as_echo_n "checking for $ac_header... " >&6; }
11528 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11529 <  $as_echo_n "(cached) " >&6
11530 < else
11531 <  eval "$as_ac_Header=\$ac_header_preproc"
11532 < fi
11533 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11534 <                 $as_echo "$as_val"'`
11535 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11536 < $as_echo "$ac_res" >&6; }
11537 <
11538 < fi
11539 < if test `eval 'as_val=${'$as_ac_Header'}
11540 <                 $as_echo "$as_val"'` = yes; then
6644 > do :
6645 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6646 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
6647 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
6648    cat >>confdefs.h <<_ACEOF
6649   #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6650   _ACEOF
# Line 11546 | Line 6653 | done
6653  
6654   done
6655  
6656 < { $as_echo "$as_me:$LINENO: checking types of arguments for select" >&5
6656 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking types of arguments for select" >&5
6657   $as_echo_n "checking types of arguments for select... " >&6; }
6658 < if test "${ac_cv_func_select_args+set}" = set; then
6658 > if ${ac_cv_func_select_args+:} false; then :
6659    $as_echo_n "(cached) " >&6
6660   else
6661    for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
6662   for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
6663    for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
6664 <   cat >conftest.$ac_ext <<_ACEOF
11558 < /* confdefs.h.  */
11559 < _ACEOF
11560 < cat confdefs.h >>conftest.$ac_ext
11561 < cat >>conftest.$ac_ext <<_ACEOF
6664 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6665   /* end confdefs.h.  */
6666   $ac_includes_default
6667   #ifdef HAVE_SYS_SELECT_H
# Line 11568 | Line 6671 | $ac_includes_default
6671   # include <sys/socket.h>
6672   #endif
6673  
11571 – #ifdef FC_DUMMY_MAIN
11572 – #ifndef FC_DUMMY_MAIN_EQ_F77
11573 – #  ifdef __cplusplus
11574 –     extern "C"
11575 – #  endif
11576 –   int FC_DUMMY_MAIN() { return 1; }
11577 – #endif
11578 – #endif
6674   int
6675   main ()
6676   {
# Line 11586 | Line 6681 | _ACEOF
6681    return 0;
6682   }
6683   _ACEOF
6684 < rm -f conftest.$ac_objext
11590 < if { (ac_try="$ac_compile"
11591 < case "(($ac_try" in
11592 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11593 <  *) ac_try_echo=$ac_try;;
11594 < esac
11595 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11596 < $as_echo "$ac_try_echo") >&5
11597 <  (eval "$ac_compile") 2>conftest.er1
11598 <  ac_status=$?
11599 <  grep -v '^ *+' conftest.er1 >conftest.err
11600 <  rm -f conftest.er1
11601 <  cat conftest.err >&5
11602 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11603 <  (exit $ac_status); } && {
11604 <         test -z "$ac_c_werror_flag" ||
11605 <         test ! -s conftest.err
11606 <       } && test -s conftest.$ac_objext; then
6684 > if ac_fn_c_try_compile "$LINENO"; then :
6685    ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
11608 – else
11609 –  $as_echo "$as_me: failed program was:" >&5
11610 – sed 's/^/| /' conftest.$ac_ext >&5
11611 –
11612 –
6686   fi
11614 –
6687   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6688    done
6689   done
6690   done
6691   # Provide a safe default value.
6692 < : ${ac_cv_func_select_args='int,int *,struct timeval *'}
6692 > : "${ac_cv_func_select_args=int,int *,struct timeval *}"
6693  
6694   fi
6695 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
6695 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_select_args" >&5
6696   $as_echo "$ac_cv_func_select_args" >&6; }
6697   ac_save_IFS=$IFS; IFS=','
6698   set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
# Line 11643 | Line 6715 | rm -f conftest*
6715  
6716   rm -f conftest*
6717  
6718 < { $as_echo "$as_me:$LINENO: checking for working strtod" >&5
6718 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
6719   $as_echo_n "checking for working strtod... " >&6; }
6720 < if test "${ac_cv_func_strtod+set}" = set; then
6720 > if ${ac_cv_func_strtod+:} false; then :
6721    $as_echo_n "(cached) " >&6
6722   else
6723 <  if test "$cross_compiling" = yes; then
6723 >  if test "$cross_compiling" = yes; then :
6724    ac_cv_func_strtod=no
6725   else
6726 <  cat >conftest.$ac_ext <<_ACEOF
11655 < /* confdefs.h.  */
11656 < _ACEOF
11657 < cat confdefs.h >>conftest.$ac_ext
11658 < cat >>conftest.$ac_ext <<_ACEOF
6726 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6727   /* end confdefs.h.  */
6728  
6729   $ac_includes_default
# Line 11688 | Line 6756 | _ACEOF
6756   }
6757  
6758   _ACEOF
6759 < rm -f conftest$ac_exeext
11692 < if { (ac_try="$ac_link"
11693 < case "(($ac_try" in
11694 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11695 <  *) ac_try_echo=$ac_try;;
11696 < esac
11697 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11698 < $as_echo "$ac_try_echo") >&5
11699 <  (eval "$ac_link") 2>&5
11700 <  ac_status=$?
11701 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11702 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11703 <  { (case "(($ac_try" in
11704 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11705 <  *) ac_try_echo=$ac_try;;
11706 < esac
11707 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11708 < $as_echo "$ac_try_echo") >&5
11709 <  (eval "$ac_try") 2>&5
11710 <  ac_status=$?
11711 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11712 <  (exit $ac_status); }; }; then
6759 > if ac_fn_c_try_run "$LINENO"; then :
6760    ac_cv_func_strtod=yes
6761   else
6762 <  $as_echo "$as_me: program exited with status $ac_status" >&5
6763 < $as_echo "$as_me: failed program was:" >&5
6764 < sed 's/^/| /' conftest.$ac_ext >&5
6765 <
6766 < ( exit $ac_status )
11720 < ac_cv_func_strtod=no
11721 < fi
11722 < rm -rf conftest.dSYM
11723 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11724 < fi
11725 <
11726 <
11727 < fi
11728 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
11729 < $as_echo "$ac_cv_func_strtod" >&6; }
11730 < if test $ac_cv_func_strtod = no; then
11731 <  case " $LIBOBJS " in
11732 <  *" strtod.$ac_objext "* ) ;;
11733 <  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
11734 < ;;
11735 < esac
11736 <
11737 < { $as_echo "$as_me:$LINENO: checking for pow" >&5
11738 < $as_echo_n "checking for pow... " >&6; }
11739 < if test "${ac_cv_func_pow+set}" = set; then
11740 <  $as_echo_n "(cached) " >&6
11741 < else
11742 <  cat >conftest.$ac_ext <<_ACEOF
11743 < /* confdefs.h.  */
11744 < _ACEOF
11745 < cat confdefs.h >>conftest.$ac_ext
11746 < cat >>conftest.$ac_ext <<_ACEOF
11747 < /* end confdefs.h.  */
11748 < /* Define pow to an innocuous variant, in case <limits.h> declares pow.
11749 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11750 < #define pow innocuous_pow
11751 <
11752 < /* System header to define __stub macros and hopefully few prototypes,
11753 <    which can conflict with char pow (); below.
11754 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11755 <    <limits.h> exists even on freestanding compilers.  */
11756 <
11757 < #ifdef __STDC__
11758 < # include <limits.h>
11759 < #else
11760 < # include <assert.h>
11761 < #endif
11762 <
11763 < #undef pow
11764 <
11765 < /* Override any GCC internal prototype to avoid an error.
11766 <   Use char because int might match the return type of a GCC
11767 <   builtin and then its argument prototype would still apply.  */
11768 < #ifdef __cplusplus
11769 < extern "C"
11770 < #endif
11771 < char pow ();
11772 < /* The GNU C library defines this for functions which it implements
11773 <    to always fail with ENOSYS.  Some functions are actually named
11774 <    something starting with __ and the normal name is an alias.  */
11775 < #if defined __stub_pow || defined __stub___pow
11776 < choke me
11777 < #endif
11778 <
11779 < #ifdef FC_DUMMY_MAIN
11780 < #ifndef FC_DUMMY_MAIN_EQ_F77
11781 < #  ifdef __cplusplus
11782 <     extern "C"
11783 < #  endif
11784 <   int FC_DUMMY_MAIN() { return 1; }
11785 < #endif
11786 < #endif
11787 < int
11788 < main ()
11789 < {
11790 < return pow ();
11791 <  ;
11792 <  return 0;
11793 < }
11794 < _ACEOF
11795 < rm -f conftest.$ac_objext conftest$ac_exeext
11796 < if { (ac_try="$ac_link"
11797 < case "(($ac_try" in
11798 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11799 <  *) ac_try_echo=$ac_try;;
11800 < esac
11801 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11802 < $as_echo "$ac_try_echo") >&5
11803 <  (eval "$ac_link") 2>conftest.er1
11804 <  ac_status=$?
11805 <  grep -v '^ *+' conftest.er1 >conftest.err
11806 <  rm -f conftest.er1
11807 <  cat conftest.err >&5
11808 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11809 <  (exit $ac_status); } && {
11810 <         test -z "$ac_c_werror_flag" ||
11811 <         test ! -s conftest.err
11812 <       } && test -s conftest$ac_exeext && {
11813 <         test "$cross_compiling" = yes ||
11814 <         $as_test_x conftest$ac_exeext
11815 <       }; then
11816 <  ac_cv_func_pow=yes
11817 < else
11818 <  $as_echo "$as_me: failed program was:" >&5
11819 < sed 's/^/| /' conftest.$ac_ext >&5
6762 >  ac_cv_func_strtod=no
6763 > fi
6764 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6765 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6766 > fi
6767  
11821 –        ac_cv_func_pow=no
6768   fi
6769 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
6770 + $as_echo "$ac_cv_func_strtod" >&6; }
6771 + if test $ac_cv_func_strtod = no; then
6772 +  case " $LIBOBJS " in
6773 +  *" strtod.$ac_objext "* ) ;;
6774 +  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
6775 + ;;
6776 + esac
6777  
6778 < rm -rf conftest.dSYM
6779 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6780 <      conftest$ac_exeext conftest.$ac_ext
6778 > ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
6779 > if test "x$ac_cv_func_pow" = xyes; then :
6780 >
6781   fi
11828 – { $as_echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11829 – $as_echo "$ac_cv_func_pow" >&6; }
6782  
6783   if test $ac_cv_func_pow = no; then
6784 <  { $as_echo "$as_me:$LINENO: checking for pow in -lm" >&5
6784 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
6785   $as_echo_n "checking for pow in -lm... " >&6; }
6786 < if test "${ac_cv_lib_m_pow+set}" = set; then
6786 > if ${ac_cv_lib_m_pow+:} false; then :
6787    $as_echo_n "(cached) " >&6
6788   else
6789    ac_check_lib_save_LIBS=$LIBS
6790   LIBS="-lm  $LIBS"
6791 < cat >conftest.$ac_ext <<_ACEOF
11840 < /* confdefs.h.  */
11841 < _ACEOF
11842 < cat confdefs.h >>conftest.$ac_ext
11843 < cat >>conftest.$ac_ext <<_ACEOF
6791 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6792   /* end confdefs.h.  */
6793  
6794   /* Override any GCC internal prototype to avoid an error.
# Line 11850 | Line 6798 | char pow ();
6798   extern "C"
6799   #endif
6800   char pow ();
11853 – #ifdef FC_DUMMY_MAIN
11854 – #ifndef FC_DUMMY_MAIN_EQ_F77
11855 – #  ifdef __cplusplus
11856 –     extern "C"
11857 – #  endif
11858 –   int FC_DUMMY_MAIN() { return 1; }
11859 – #endif
11860 – #endif
6801   int
6802   main ()
6803   {
# Line 11866 | Line 6806 | _ACEOF
6806    return 0;
6807   }
6808   _ACEOF
6809 < rm -f conftest.$ac_objext conftest$ac_exeext
11870 < if { (ac_try="$ac_link"
11871 < case "(($ac_try" in
11872 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11873 <  *) ac_try_echo=$ac_try;;
11874 < esac
11875 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11876 < $as_echo "$ac_try_echo") >&5
11877 <  (eval "$ac_link") 2>conftest.er1
11878 <  ac_status=$?
11879 <  grep -v '^ *+' conftest.er1 >conftest.err
11880 <  rm -f conftest.er1
11881 <  cat conftest.err >&5
11882 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11883 <  (exit $ac_status); } && {
11884 <         test -z "$ac_c_werror_flag" ||
11885 <         test ! -s conftest.err
11886 <       } && test -s conftest$ac_exeext && {
11887 <         test "$cross_compiling" = yes ||
11888 <         $as_test_x conftest$ac_exeext
11889 <       }; then
6809 > if ac_fn_c_try_link "$LINENO"; then :
6810    ac_cv_lib_m_pow=yes
6811   else
6812 <  $as_echo "$as_me: failed program was:" >&5
11893 < sed 's/^/| /' conftest.$ac_ext >&5
11894 <
11895 <        ac_cv_lib_m_pow=no
6812 >  ac_cv_lib_m_pow=no
6813   fi
6814 <
6815 < rm -rf conftest.dSYM
11899 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11900 <      conftest$ac_exeext conftest.$ac_ext
6814 > rm -f core conftest.err conftest.$ac_objext \
6815 >    conftest$ac_exeext conftest.$ac_ext
6816   LIBS=$ac_check_lib_save_LIBS
6817   fi
6818 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
6818 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
6819   $as_echo "$ac_cv_lib_m_pow" >&6; }
6820 < if test $ac_cv_lib_m_pow = yes; then
6820 > if test "x$ac_cv_lib_m_pow" = xyes; then :
6821    POW_LIB=-lm
6822   else
6823 <  { $as_echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
6823 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
6824   $as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
6825   fi
6826  
# Line 11913 | Line 6828 | fi
6828  
6829   fi
6830  
11916 –
11917 –
11918 –
11919 –
11920 –
11921 –
11922 –
11923 –
11924 –
11925 –
11926 –
11927 –
11928 –
11929 –
11930 –
11931 –
11932 –
11933 –
11934 –
11935 –
11936 –
6831   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
6832 < do
6833 < as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
6834 < { $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
6835 < $as_echo_n "checking for $ac_func... " >&6; }
11942 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11943 <  $as_echo_n "(cached) " >&6
11944 < else
11945 <  cat >conftest.$ac_ext <<_ACEOF
11946 < /* confdefs.h.  */
11947 < _ACEOF
11948 < cat confdefs.h >>conftest.$ac_ext
11949 < cat >>conftest.$ac_ext <<_ACEOF
11950 < /* end confdefs.h.  */
11951 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11952 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11953 < #define $ac_func innocuous_$ac_func
11954 <
11955 < /* System header to define __stub macros and hopefully few prototypes,
11956 <    which can conflict with char $ac_func (); below.
11957 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11958 <    <limits.h> exists even on freestanding compilers.  */
11959 <
11960 < #ifdef __STDC__
11961 < # include <limits.h>
11962 < #else
11963 < # include <assert.h>
11964 < #endif
11965 <
11966 < #undef $ac_func
11967 <
11968 < /* Override any GCC internal prototype to avoid an error.
11969 <   Use char because int might match the return type of a GCC
11970 <   builtin and then its argument prototype would still apply.  */
11971 < #ifdef __cplusplus
11972 < extern "C"
11973 < #endif
11974 < char $ac_func ();
11975 < /* The GNU C library defines this for functions which it implements
11976 <    to always fail with ENOSYS.  Some functions are actually named
11977 <    something starting with __ and the normal name is an alias.  */
11978 < #if defined __stub_$ac_func || defined __stub___$ac_func
11979 < choke me
11980 < #endif
11981 <
11982 < #ifdef FC_DUMMY_MAIN
11983 < #ifndef FC_DUMMY_MAIN_EQ_F77
11984 < #  ifdef __cplusplus
11985 <     extern "C"
11986 < #  endif
11987 <   int FC_DUMMY_MAIN() { return 1; }
11988 < #endif
11989 < #endif
11990 < int
11991 < main ()
11992 < {
11993 < return $ac_func ();
11994 <  ;
11995 <  return 0;
11996 < }
11997 < _ACEOF
11998 < rm -f conftest.$ac_objext conftest$ac_exeext
11999 < if { (ac_try="$ac_link"
12000 < case "(($ac_try" in
12001 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12002 <  *) ac_try_echo=$ac_try;;
12003 < esac
12004 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12005 < $as_echo "$ac_try_echo") >&5
12006 <  (eval "$ac_link") 2>conftest.er1
12007 <  ac_status=$?
12008 <  grep -v '^ *+' conftest.er1 >conftest.err
12009 <  rm -f conftest.er1
12010 <  cat conftest.err >&5
12011 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12012 <  (exit $ac_status); } && {
12013 <         test -z "$ac_c_werror_flag" ||
12014 <         test ! -s conftest.err
12015 <       } && test -s conftest$ac_exeext && {
12016 <         test "$cross_compiling" = yes ||
12017 <         $as_test_x conftest$ac_exeext
12018 <       }; then
12019 <  eval "$as_ac_var=yes"
12020 < else
12021 <  $as_echo "$as_me: failed program was:" >&5
12022 < sed 's/^/| /' conftest.$ac_ext >&5
12023 <
12024 <        eval "$as_ac_var=no"
12025 < fi
12026 <
12027 < rm -rf conftest.dSYM
12028 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12029 <      conftest$ac_exeext conftest.$ac_ext
12030 < fi
12031 < ac_res=`eval 'as_val=${'$as_ac_var'}
12032 <                 $as_echo "$as_val"'`
12033 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
12034 < $as_echo "$ac_res" >&6; }
12035 < if test `eval 'as_val=${'$as_ac_var'}
12036 <                 $as_echo "$as_val"'` = yes; then
6832 > do :
6833 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
6834 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
6835 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
6836    cat >>confdefs.h <<_ACEOF
6837   #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
6838   _ACEOF
# Line 12044 | Line 6843 | done
6843  
6844   # special check for _system_configuration because AIX <4.3.2 do not
6845   # contain the `physmem' member.
6846 < { $as_echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
6846 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for external symbol _system_configuration" >&5
6847   $as_echo_n "checking for external symbol _system_configuration... " >&6; }
6848 < cat >conftest.$ac_ext <<_ACEOF
12050 < /* confdefs.h.  */
12051 < _ACEOF
12052 < cat confdefs.h >>conftest.$ac_ext
12053 < cat >>conftest.$ac_ext <<_ACEOF
6848 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6849   /* end confdefs.h.  */
6850   #include <sys/systemcfg.h>
12056 – #ifdef FC_DUMMY_MAIN
12057 – #ifndef FC_DUMMY_MAIN_EQ_F77
12058 – #  ifdef __cplusplus
12059 –     extern "C"
12060 – #  endif
12061 –   int FC_DUMMY_MAIN() { return 1; }
12062 – #endif
12063 – #endif
6851   int
6852   main ()
6853   {
# Line 12069 | Line 6856 | _ACEOF
6856    return 0;
6857   }
6858   _ACEOF
6859 < rm -f conftest.$ac_objext
6860 < if { (ac_try="$ac_compile"
12074 < case "(($ac_try" in
12075 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12076 <  *) ac_try_echo=$ac_try;;
12077 < esac
12078 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12079 < $as_echo "$ac_try_echo") >&5
12080 <  (eval "$ac_compile") 2>conftest.er1
12081 <  ac_status=$?
12082 <  grep -v '^ *+' conftest.er1 >conftest.err
12083 <  rm -f conftest.er1
12084 <  cat conftest.err >&5
12085 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12086 <  (exit $ac_status); } && {
12087 <         test -z "$ac_c_werror_flag" ||
12088 <         test ! -s conftest.err
12089 <       } && test -s conftest.$ac_objext; then
12090 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
6859 > if ac_fn_c_try_compile "$LINENO"; then :
6860 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6861   $as_echo "yes" >&6; }
6862  
6863 < cat >>confdefs.h <<\_ACEOF
12094 < #define HAVE__SYSTEM_CONFIGURATION 1
12095 < _ACEOF
6863 > $as_echo "#define HAVE__SYSTEM_CONFIGURATION 1" >>confdefs.h
6864  
6865   else
6866 <  $as_echo "$as_me: failed program was:" >&5
12099 < sed 's/^/| /' conftest.$ac_ext >&5
12100 <
12101 <        { $as_echo "$as_me:$LINENO: result: no" >&5
6866 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6867   $as_echo "no" >&6; }
6868   fi
12104 –
6869   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6870  
6871  
# Line 12109 | Line 6873 | case $debug in
6873    1)
6874       ;;
6875    *)
12112 –
12113 –
12114 –
12115 –
12116 –
12117 – # Try to determine "good" native compiler flags if none specified on command
12118 – # line
6876  
12120 – if test "$ac_test_FFLAGS" != "set"; then
12121 –  FCFLAGS=""
12122 –  case "${host_cpu}-${host_os}" in
6877  
12124 –  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12125 –                    FCFLAGS="-O2"
12126 –                fi;;
12127 –   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12128 –                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12129 –                fi;;
12130 –   powerpc*-aix*)
12131 –        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12132 –                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12133 –                echo "*******************************************************"
12134 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12135 –                echo "*  recommended that you use                           *"
12136 –                echo "*                                                     *"
12137 –                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12138 –                echo "*                                 ^^^                 *"
12139 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12140 –                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12141 –                echo "*******************************************************"
12142 –        fi;;
12143 –   *darwin*)
12144 –        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12145 –                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12146 –        fi
12147 –        if test "$FC" = ifort; then
12148 –                FCFLAGS="-O2"
12149 –        fi
12150 –        if test "$FC" = gfortran; then
12151 –                FCFLAGS="-Os"
12152 –        fi;;
12153 –  esac
6878  
12155 –  if test -z "$FCFLAGS"; then
12156 –        echo ""
12157 –        echo "*********************************************************"
12158 –        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12159 –        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12160 –        echo "* (otherwise, a default of FCFLAGS=-O will be used)     *"
12161 –        echo "*********************************************************"
12162 –        echo ""
12163 –        FCFLAGS="-O"
12164 –  fi
6879  
6880  
12167 – { $as_echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12168 – $as_echo_n "checking whether ${FC} accepts ${FCFLAGS}... " >&6; }
12169 – if test "${ac_guessed_f90flags+set}" = set; then
12170 –  $as_echo_n "(cached) " >&6
12171 – else
6881  
6882 <
12174 < ac_ext=${ac_fc_srcext-f}
12175 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
12176 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
12177 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12178 <
12179 < echo 'program main' > conftest.$ac_ext
12180 < echo 'end program main' >> conftest.$ac_ext
12181 < ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12182 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12183 <  (eval $ac_compile) 2>&5
12184 <  ac_status=$?
12185 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12186 <  (exit $ac_status); }; then
12187 <        ac_guessed_f90flags=yes
12188 < else
12189 <        ac_guessed_f90flags=no
12190 < fi
12191 < rm -f conftest*
12192 < ac_ext=c
12193 < ac_cpp='$CPP $CPPFLAGS'
12194 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12195 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12196 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
12197 <
12198 <
12199 < fi
12200 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12201 < $as_echo "$ac_guessed_f90flags" >&6; }
12202 < if test "$ac_guessed_f90flags" = yes; then
12203 <        :
12204 <
12205 < else
12206 <        :
12207 <
12208 <        echo ""
12209 <        echo "**********************************************************"
12210 <        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12211 <        echo "* your compiler.                                        *"
12212 <        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12213 <        echo "*********************************************************"
12214 <        echo ""
12215 <        FCFLAGS=""
12216 <
12217 < fi
12218 <
12219 <
12220 < fi
12221 <
12222 <
12223 <
12224 <
12225 <
12226 <
12227 <
12228 < { $as_echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
6882 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU cc" >&5
6883   $as_echo_n "checking whether we are *really* using GNU cc... " >&6; }
6884 < if test "${ac_cv_prog_really_gcc+set}" = set; then
6884 > if ${ac_cv_prog_really_gcc+:} false; then :
6885    $as_echo_n "(cached) " >&6
6886   else
6887  
# Line 12241 | Line 6895 | if { ac_try='${CC-cc} -E conftest.c'
6895   #endif
6896   EOF
6897   if { ac_try='${CC-cc} -E conftest.c'
6898 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6898 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
6899    (eval $ac_try) 2>&5
6900    ac_status=$?
6901 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6902 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
6901 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6902 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
6903    ac_cv_prog_really_gcc=yes
6904   else
6905    ac_cv_prog_really_gcc=no
6906   fi
6907  
6908   fi
6909 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
6909 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gcc" >&5
6910   $as_echo "$ac_cv_prog_really_gcc" >&6; }
6911   if test "$ac_cv_prog_really_gcc" = yes; then
6912          :
# Line 12330 | Line 6984 | if test "$ac_test_CFLAGS" != "set"; then
6984  
6985  
6986  
6987 < { $as_echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
6987 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts ${CFLAGS}" >&5
6988   $as_echo_n "checking whether ${CC} accepts ${CFLAGS}... " >&6; }
6989 < if test "${ac_guessed_cflags+set}" = set; then
6989 > if ${ac_cv_ac_cv_guessed_cflags+:} false; then :
6990    $as_echo_n "(cached) " >&6
6991   else
6992    echo 'void f(){}' > conftest.c
6993   if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
6994 <        ac_guessed_cflags=yes
6994 >        ac_cv_ac_cv_guessed_cflags=yes
6995   else
6996 <        ac_guessed_cflags=no
6996 >        ac_cv_ac_cv_guessed_cflags=no
6997   fi
6998   rm -f conftest*
6999  
7000   fi
7001 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
7002 < $as_echo "$ac_guessed_cflags" >&6; }
7003 < if test "$ac_guessed_cflags" = yes; then
7001 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cflags" >&5
7002 > $as_echo "$ac_cv_ac_cv_guessed_cflags" >&6; }
7003 > if test "$ac_cv_ac_cv_guessed_cflags" = yes; then
7004          :
7005  
7006   else
# Line 12362 | Line 7016 | fi
7016          CFLAGS=""
7017  
7018   fi
12365 –
12366 –
12367 – fi
12368 –
12369 –
12370 –
12371 –
12372 –
12373 –
12374 –
12375 – { $as_echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
12376 – $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
12377 – if test "${ac_cv_prog_really_gxx+set}" = set; then
12378 –  $as_echo_n "(cached) " >&6
12379 – else
12380 –
12381 – cat > conftest.cpp <<EOF
12382 – #ifdef __GNUC__
12383 –  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12384 –     no;
12385 –  #else
12386 –     yes;
12387 –  #endif
12388 – #endif
12389 – EOF
12390 – if { ac_try='${CXX-c++} -E conftest.cpp'
12391 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12392 –  (eval $ac_try) 2>&5
12393 –  ac_status=$?
12394 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12395 –  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12396 –  ac_cv_prog_really_gxx=yes
12397 – else
12398 –  ac_cv_prog_really_gxx=no
12399 – fi
12400 –
12401 – fi
12402 – { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
12403 – $as_echo "$ac_cv_prog_really_gxx" >&6; }
12404 – if test "$ac_cv_prog_really_gxx" = yes; then
12405 –        :
12406 –
12407 – else
12408 –        :
12409 –
12410 – fi
12411 –
12412 –
12413 – # Try to determine "good" native compiler flags if none specified on command
12414 – # line
12415 – if test "$ac_test_CXXFLAGS" != "set"; then
12416 –  CXXFLAGS=""
12417 –  case "${host_cpu}-${host_os}" in
12418 –
12419 –  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
12420 –                    CXXFLAGS="-O2"
12421 –                fi;;
12422 –  sparc-solaris2*) if test "$CXX" = CC; then
12423 –                    CXXFLAGS="-features=extensions -O -dalign"
12424 –                 fi;;
12425 –   rs6000*-aix*)  if test "$CXX" = xlC; then
12426 –                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12427 –                fi;;
12428 –   powerpc*-aix*)
12429 –        if test "$CXX" = xlC; then
12430 –                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
12431 –                echo "*******************************************************"
12432 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12433 –                echo "*  recommended that you use                           *"
12434 –                echo "*                                                     *"
12435 –                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12436 –                echo "*                                 ^^^                 *"
12437 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12438 –                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12439 –                echo "*******************************************************"
12440 –        fi;;
12441 –   *darwin*)
12442 –        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12443 –                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12444 –        fi
12445 –        if test "$CXX" = icpc; then
12446 –                CXXFLAGS="-O2"
12447 –        fi
12448 –        if test $ac_cv_prog_really_gxx = yes; then
12449 –                CXXFLAGS="-Os"
12450 –        fi;;
12451 –  esac
12452 –
12453 –  # use default flags for gcc on all systems
12454 –  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
12455 –     CXXFLAGS="-O2"
12456 –  fi
12457 –
12458 –  if test -z "$CXXFLAGS"; then
12459 –        echo ""
12460 –        echo "**********************************************************"
12461 –        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12462 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12463 –        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
12464 –        echo "**********************************************************"
12465 –        echo ""
12466 –        CXXFLAGS="-O"
12467 –  fi
12468 –
12469 –
12470 –
12471 – { $as_echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12472 – $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
12473 – if test "${ac_guessed_cxxflags+set}" = set; then
12474 –  $as_echo_n "(cached) " >&6
12475 – else
12476 –  echo 'void f(){}' > conftest.cpp
12477 – if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12478 –        ac_guessed_cxxflags=yes
12479 – else
12480 –        ac_guessed_cxxflags=no
12481 – fi
12482 – rm -f conftest*
12483 –
12484 – fi
12485 – { $as_echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12486 – $as_echo "$ac_guessed_cxxflags" >&6; }
12487 – if test "$ac_guessed_cxxflags" = yes; then
12488 –        :
12489 –
12490 – else
12491 –        :
12492 –
12493 –        echo ""
12494 –        echo "**********************************************************"
12495 –        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12496 –        echo "* your compiler.                                         *"
12497 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12498 –        echo "**********************************************************"
12499 –        echo ""
12500 –        CXXFLAGS=""
12501 –
12502 – fi
12503 –
12504 –
12505 – fi
12506 –
12507 –     ;;
12508 – esac
12509 –
12510 –
12511 – acx_cgal_found=no
12512 –
12513 – # Check whether --with-cgalmakefile was given.
12514 – if test "${with_cgalmakefile+set}" = set; then
12515 –  withval=$with_cgalmakefile;
12516 – fi
12517 –
12518 – case $with_cgalmakefile in
12519 –        yes | "") ;;
12520 –        no) acx_cgal_found=disable ;;
12521 –        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
12522 –        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
12523 – esac
12524 –
12525 – if test "$acx_cgal_found" == no; then
12526 –    { $as_echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
12527 – $as_echo_n "checking CGAL_MAKEFILE... " >&6; }
12528 –
12529 –    if test \! -z "$CGAL_MAKEFILE"; then
12530 –
12531 –        if test -e "$CGAL_MAKEFILE"; then
12532 –            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
12533 –
12534 – cat > $tname << _ACEOF
12535 – include $CGAL_MAKEFILE
12536 –
12537 – cppflags:
12538 –        @echo \$(CGAL_CXXFLAGS)
12539 –
12540 – cxxflags:
12541 –        @echo
12542 – ldflags:
12543 –        @echo \$(CGAL_LDFLAGS)
12544 – _ACEOF
12545 –            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
12546 –            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
12547 –            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
12548 –            for i in $CGAL_LDFLAGST; do
12549 –                if test `echo $i| grep -c ^-l`; then
12550 –                    CGAL_LIBS="$CGAL_LIBS $i"
12551 –                else
12552 –                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
12553 –                fi
12554 –            done
12555 –            rm -f $tname
12556 –            { $as_echo "$as_me:$LINENO: result: yes" >&5
12557 – $as_echo "yes" >&6; }
12558 –            acx_cgal_found=yes
12559 –                                   else
12560 –            { $as_echo "$as_me:$LINENO: result: invalid" >&5
12561 – $as_echo "invalid" >&6; }
12562 –            { { $as_echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
12563 – $as_echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
12564 –   { (exit 1); exit 1; }; }
12565 –        fi
12566 –    else
12567 –        { $as_echo "$as_me:$LINENO: result: not defined" >&5
12568 – $as_echo "not defined" >&6; }
12569 –    fi
12570 – fi
12571 –
12572 – if test "$acx_cgal_found" == no; then
12573 –        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12574 –  { $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12575 – $as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12576 – if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12577 –  $as_echo_n "(cached) " >&6
12578 – fi
12579 – { $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12580 – $as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12581 – else
12582 –  # Is the header compilable?
12583 – { $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
12584 – $as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... " >&6; }
12585 – cat >conftest.$ac_ext <<_ACEOF
12586 – /* confdefs.h.  */
12587 – _ACEOF
12588 – cat confdefs.h >>conftest.$ac_ext
12589 – cat >>conftest.$ac_ext <<_ACEOF
12590 – /* end confdefs.h.  */
12591 – $ac_includes_default
12592 – #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12593 – _ACEOF
12594 – rm -f conftest.$ac_objext
12595 – if { (ac_try="$ac_compile"
12596 – case "(($ac_try" in
12597 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12598 –  *) ac_try_echo=$ac_try;;
12599 – esac
12600 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12601 – $as_echo "$ac_try_echo") >&5
12602 –  (eval "$ac_compile") 2>conftest.er1
12603 –  ac_status=$?
12604 –  grep -v '^ *+' conftest.er1 >conftest.err
12605 –  rm -f conftest.er1
12606 –  cat conftest.err >&5
12607 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12608 –  (exit $ac_status); } && {
12609 –         test -z "$ac_c_werror_flag" ||
12610 –         test ! -s conftest.err
12611 –       } && test -s conftest.$ac_objext; then
12612 –  ac_header_compiler=yes
12613 – else
12614 –  $as_echo "$as_me: failed program was:" >&5
12615 – sed 's/^/| /' conftest.$ac_ext >&5
12616 –
12617 –        ac_header_compiler=no
12618 – fi
12619 –
12620 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12621 – { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12622 – $as_echo "$ac_header_compiler" >&6; }
12623 –
12624 – # Is the header present?
12625 – { $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
12626 – $as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... " >&6; }
12627 – cat >conftest.$ac_ext <<_ACEOF
12628 – /* confdefs.h.  */
12629 – _ACEOF
12630 – cat confdefs.h >>conftest.$ac_ext
12631 – cat >>conftest.$ac_ext <<_ACEOF
12632 – /* end confdefs.h.  */
12633 – #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12634 – _ACEOF
12635 – if { (ac_try="$ac_cpp conftest.$ac_ext"
12636 – case "(($ac_try" in
12637 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12638 –  *) ac_try_echo=$ac_try;;
12639 – esac
12640 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12641 – $as_echo "$ac_try_echo") >&5
12642 –  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
12643 –  ac_status=$?
12644 –  grep -v '^ *+' conftest.er1 >conftest.err
12645 –  rm -f conftest.er1
12646 –  cat conftest.err >&5
12647 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12648 –  (exit $ac_status); } >/dev/null && {
12649 –         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12650 –         test ! -s conftest.err
12651 –       }; then
12652 –  ac_header_preproc=yes
12653 – else
12654 –  $as_echo "$as_me: failed program was:" >&5
12655 – sed 's/^/| /' conftest.$ac_ext >&5
12656 –
12657 –  ac_header_preproc=no
12658 – fi
12659 –
12660 – rm -f conftest.err conftest.$ac_ext
12661 – { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
12662 – $as_echo "$ac_header_preproc" >&6; }
12663 –
12664 – # So?  What about this header?
12665 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12666 –  yes:no: )
12667 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
12668 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
12669 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
12670 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
12671 –    ac_header_preproc=yes
12672 –    ;;
12673 –  no:yes:* )
12674 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
12675 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
12676 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
12677 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
12678 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
12679 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
12680 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
12681 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
12682 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
12683 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
12684 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
12685 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
12686 –    ( cat <<\_ASBOX
12687 – ## ------------------------------ ##
12688 – ## Report this to gezelter@nd.edu ##
12689 – ## ------------------------------ ##
12690 – _ASBOX
12691 –     ) | sed "s/^/$as_me: WARNING:     /" >&2
12692 –    ;;
12693 – esac
12694 – { $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12695 – $as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12696 – if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12697 –  $as_echo_n "(cached) " >&6
12698 – else
12699 –  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
12700 – fi
12701 – { $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12702 – $as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12703 –
12704 – fi
12705 – if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
12706 –  cgal_have_header=yes
12707 – else
12708 –  cgal_have_header=no
12709 – fi
12710 –
12711 –
12712 –        if test "$cgal_have_header" == yes; then
12713 –                { $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
12714 – $as_echo_n "checking for main in -lCGAL... " >&6; }
12715 – if test "${ac_cv_lib_CGAL_main+set}" = set; then
12716 –  $as_echo_n "(cached) " >&6
12717 – else
12718 –  ac_check_lib_save_LIBS=$LIBS
12719 – LIBS="-lCGAL  $LIBS"
12720 – cat >conftest.$ac_ext <<_ACEOF
12721 – /* confdefs.h.  */
12722 – _ACEOF
12723 – cat confdefs.h >>conftest.$ac_ext
12724 – cat >>conftest.$ac_ext <<_ACEOF
12725 – /* end confdefs.h.  */
12726 –
12727 –
12728 – #ifdef FC_DUMMY_MAIN
12729 – #ifndef FC_DUMMY_MAIN_EQ_F77
12730 – #  ifdef __cplusplus
12731 –     extern "C"
12732 – #  endif
12733 –   int FC_DUMMY_MAIN() { return 1; }
12734 – #endif
12735 – #endif
12736 – int
12737 – main ()
12738 – {
12739 – return main ();
12740 –  ;
12741 –  return 0;
12742 – }
12743 – _ACEOF
12744 – rm -f conftest.$ac_objext conftest$ac_exeext
12745 – if { (ac_try="$ac_link"
12746 – case "(($ac_try" in
12747 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12748 –  *) ac_try_echo=$ac_try;;
12749 – esac
12750 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12751 – $as_echo "$ac_try_echo") >&5
12752 –  (eval "$ac_link") 2>conftest.er1
12753 –  ac_status=$?
12754 –  grep -v '^ *+' conftest.er1 >conftest.err
12755 –  rm -f conftest.er1
12756 –  cat conftest.err >&5
12757 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12758 –  (exit $ac_status); } && {
12759 –         test -z "$ac_c_werror_flag" ||
12760 –         test ! -s conftest.err
12761 –       } && test -s conftest$ac_exeext && {
12762 –         test "$cross_compiling" = yes ||
12763 –         $as_test_x conftest$ac_exeext
12764 –       }; then
12765 –  ac_cv_lib_CGAL_main=yes
12766 – else
12767 –  $as_echo "$as_me: failed program was:" >&5
12768 – sed 's/^/| /' conftest.$ac_ext >&5
12769 –
12770 –        ac_cv_lib_CGAL_main=no
12771 – fi
12772 –
12773 – rm -rf conftest.dSYM
12774 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12775 –      conftest$ac_exeext conftest.$ac_ext
12776 – LIBS=$ac_check_lib_save_LIBS
12777 – fi
12778 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
12779 – $as_echo "$ac_cv_lib_CGAL_main" >&6; }
12780 – if test $ac_cv_lib_CGAL_main = yes; then
12781 –  cgal_have_lib=yes
12782 – else
12783 –  cgal_have_lib=no
12784 – fi
12785 –
12786 –                if test "$cgal_have_lib" == no; then
12787 –                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
12788 –                        { $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
12789 – $as_echo_n "checking for main in -lCGAL... " >&6; }
12790 – if test "${ac_cv_lib_CGAL_main+set}" = set; then
12791 –  $as_echo_n "(cached) " >&6
12792 – else
12793 –  ac_check_lib_save_LIBS=$LIBS
12794 – LIBS="-lCGAL  $LIBS"
12795 – cat >conftest.$ac_ext <<_ACEOF
12796 – /* confdefs.h.  */
12797 – _ACEOF
12798 – cat confdefs.h >>conftest.$ac_ext
12799 – cat >>conftest.$ac_ext <<_ACEOF
12800 – /* end confdefs.h.  */
12801 –
12802 –
12803 – #ifdef FC_DUMMY_MAIN
12804 – #ifndef FC_DUMMY_MAIN_EQ_F77
12805 – #  ifdef __cplusplus
12806 –     extern "C"
12807 – #  endif
12808 –   int FC_DUMMY_MAIN() { return 1; }
12809 – #endif
12810 – #endif
12811 – int
12812 – main ()
12813 – {
12814 – return main ();
12815 –  ;
12816 –  return 0;
12817 – }
12818 – _ACEOF
12819 – rm -f conftest.$ac_objext conftest$ac_exeext
12820 – if { (ac_try="$ac_link"
12821 – case "(($ac_try" in
12822 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12823 –  *) ac_try_echo=$ac_try;;
12824 – esac
12825 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12826 – $as_echo "$ac_try_echo") >&5
12827 –  (eval "$ac_link") 2>conftest.er1
12828 –  ac_status=$?
12829 –  grep -v '^ *+' conftest.er1 >conftest.err
12830 –  rm -f conftest.er1
12831 –  cat conftest.err >&5
12832 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12833 –  (exit $ac_status); } && {
12834 –         test -z "$ac_c_werror_flag" ||
12835 –         test ! -s conftest.err
12836 –       } && test -s conftest$ac_exeext && {
12837 –         test "$cross_compiling" = yes ||
12838 –         $as_test_x conftest$ac_exeext
12839 –       }; then
12840 –  ac_cv_lib_CGAL_main=yes
12841 – else
12842 –  $as_echo "$as_me: failed program was:" >&5
12843 – sed 's/^/| /' conftest.$ac_ext >&5
12844 –
12845 –        ac_cv_lib_CGAL_main=no
12846 – fi
12847 –
12848 – rm -rf conftest.dSYM
12849 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12850 –      conftest$ac_exeext conftest.$ac_ext
12851 – LIBS=$ac_check_lib_save_LIBS
12852 – fi
12853 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
12854 – $as_echo "$ac_cv_lib_CGAL_main" >&6; }
12855 – if test $ac_cv_lib_CGAL_main = yes; then
12856 –  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
12857 –                                                  cgal_have_lib=yes
12858 – else
12859 –  cgal_have_lib=no
12860 – fi
12861 –
12862 –                        LIBS="$save_LIBS"
12863 –                else
12864 –                        CGAL_LIBS="-lCGAL"
12865 –                        { $as_echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
12866 – $as_echo_n "checking for main in -lmpfr... " >&6; }
12867 – if test "${ac_cv_lib_mpfr_main+set}" = set; then
12868 –  $as_echo_n "(cached) " >&6
12869 – else
12870 –  ac_check_lib_save_LIBS=$LIBS
12871 – LIBS="-lmpfr  $LIBS"
12872 – cat >conftest.$ac_ext <<_ACEOF
12873 – /* confdefs.h.  */
12874 – _ACEOF
12875 – cat confdefs.h >>conftest.$ac_ext
12876 – cat >>conftest.$ac_ext <<_ACEOF
12877 – /* end confdefs.h.  */
12878 –
12879 –
12880 – #ifdef FC_DUMMY_MAIN
12881 – #ifndef FC_DUMMY_MAIN_EQ_F77
12882 – #  ifdef __cplusplus
12883 –     extern "C"
12884 – #  endif
12885 –   int FC_DUMMY_MAIN() { return 1; }
12886 – #endif
12887 – #endif
12888 – int
12889 – main ()
12890 – {
12891 – return main ();
12892 –  ;
12893 –  return 0;
12894 – }
12895 – _ACEOF
12896 – rm -f conftest.$ac_objext conftest$ac_exeext
12897 – if { (ac_try="$ac_link"
12898 – case "(($ac_try" in
12899 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12900 –  *) ac_try_echo=$ac_try;;
12901 – esac
12902 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12903 – $as_echo "$ac_try_echo") >&5
12904 –  (eval "$ac_link") 2>conftest.er1
12905 –  ac_status=$?
12906 –  grep -v '^ *+' conftest.er1 >conftest.err
12907 –  rm -f conftest.er1
12908 –  cat conftest.err >&5
12909 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12910 –  (exit $ac_status); } && {
12911 –         test -z "$ac_c_werror_flag" ||
12912 –         test ! -s conftest.err
12913 –       } && test -s conftest$ac_exeext && {
12914 –         test "$cross_compiling" = yes ||
12915 –         $as_test_x conftest$ac_exeext
12916 –       }; then
12917 –  ac_cv_lib_mpfr_main=yes
12918 – else
12919 –  $as_echo "$as_me: failed program was:" >&5
12920 – sed 's/^/| /' conftest.$ac_ext >&5
12921 –
12922 –        ac_cv_lib_mpfr_main=no
12923 – fi
12924 –
12925 – rm -rf conftest.dSYM
12926 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12927 –      conftest$ac_exeext conftest.$ac_ext
12928 – LIBS=$ac_check_lib_save_LIBS
12929 – fi
12930 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
12931 – $as_echo "$ac_cv_lib_mpfr_main" >&6; }
12932 – if test $ac_cv_lib_mpfr_main = yes; then
12933 –  CGAL_LIBS="$CGAL_LIBS -lmpfr"
12934 – fi
12935 –
12936 –                        { $as_echo "$as_me:$LINENO: checking for main in -lgmp" >&5
12937 – $as_echo_n "checking for main in -lgmp... " >&6; }
12938 – if test "${ac_cv_lib_gmp_main+set}" = set; then
12939 –  $as_echo_n "(cached) " >&6
12940 – else
12941 –  ac_check_lib_save_LIBS=$LIBS
12942 – LIBS="-lgmp  $LIBS"
12943 – cat >conftest.$ac_ext <<_ACEOF
12944 – /* confdefs.h.  */
12945 – _ACEOF
12946 – cat confdefs.h >>conftest.$ac_ext
12947 – cat >>conftest.$ac_ext <<_ACEOF
12948 – /* end confdefs.h.  */
12949 –
12950 –
12951 – #ifdef FC_DUMMY_MAIN
12952 – #ifndef FC_DUMMY_MAIN_EQ_F77
12953 – #  ifdef __cplusplus
12954 –     extern "C"
12955 – #  endif
12956 –   int FC_DUMMY_MAIN() { return 1; }
12957 – #endif
12958 – #endif
12959 – int
12960 – main ()
12961 – {
12962 – return main ();
12963 –  ;
12964 –  return 0;
12965 – }
12966 – _ACEOF
12967 – rm -f conftest.$ac_objext conftest$ac_exeext
12968 – if { (ac_try="$ac_link"
12969 – case "(($ac_try" in
12970 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12971 –  *) ac_try_echo=$ac_try;;
12972 – esac
12973 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12974 – $as_echo "$ac_try_echo") >&5
12975 –  (eval "$ac_link") 2>conftest.er1
12976 –  ac_status=$?
12977 –  grep -v '^ *+' conftest.er1 >conftest.err
12978 –  rm -f conftest.er1
12979 –  cat conftest.err >&5
12980 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12981 –  (exit $ac_status); } && {
12982 –         test -z "$ac_c_werror_flag" ||
12983 –         test ! -s conftest.err
12984 –       } && test -s conftest$ac_exeext && {
12985 –         test "$cross_compiling" = yes ||
12986 –         $as_test_x conftest$ac_exeext
12987 –       }; then
12988 –  ac_cv_lib_gmp_main=yes
12989 – else
12990 –  $as_echo "$as_me: failed program was:" >&5
12991 – sed 's/^/| /' conftest.$ac_ext >&5
7019  
12993 –        ac_cv_lib_gmp_main=no
12994 – fi
7020  
12996 – rm -rf conftest.dSYM
12997 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12998 –      conftest$ac_exeext conftest.$ac_ext
12999 – LIBS=$ac_check_lib_save_LIBS
7021   fi
13001 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
13002 – $as_echo "$ac_cv_lib_gmp_main" >&6; }
13003 – if test $ac_cv_lib_gmp_main = yes; then
13004 –  CGAL_LIBS="$CGAL_LIBS -lgmp"
13005 – fi
7022  
13007 –                        { $as_echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
13008 – $as_echo_n "checking for main in -lgmpxx... " >&6; }
13009 – if test "${ac_cv_lib_gmpxx_main+set}" = set; then
13010 –  $as_echo_n "(cached) " >&6
13011 – else
13012 –  ac_check_lib_save_LIBS=$LIBS
13013 – LIBS="-lgmpxx  $LIBS"
13014 – cat >conftest.$ac_ext <<_ACEOF
13015 – /* confdefs.h.  */
13016 – _ACEOF
13017 – cat confdefs.h >>conftest.$ac_ext
13018 – cat >>conftest.$ac_ext <<_ACEOF
13019 – /* end confdefs.h.  */
7023  
7024  
13022 – #ifdef FC_DUMMY_MAIN
13023 – #ifndef FC_DUMMY_MAIN_EQ_F77
13024 – #  ifdef __cplusplus
13025 –     extern "C"
13026 – #  endif
13027 –   int FC_DUMMY_MAIN() { return 1; }
13028 – #endif
13029 – #endif
13030 – int
13031 – main ()
13032 – {
13033 – return main ();
13034 –  ;
13035 –  return 0;
13036 – }
13037 – _ACEOF
13038 – rm -f conftest.$ac_objext conftest$ac_exeext
13039 – if { (ac_try="$ac_link"
13040 – case "(($ac_try" in
13041 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13042 –  *) ac_try_echo=$ac_try;;
13043 – esac
13044 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13045 – $as_echo "$ac_try_echo") >&5
13046 –  (eval "$ac_link") 2>conftest.er1
13047 –  ac_status=$?
13048 –  grep -v '^ *+' conftest.er1 >conftest.err
13049 –  rm -f conftest.er1
13050 –  cat conftest.err >&5
13051 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13052 –  (exit $ac_status); } && {
13053 –         test -z "$ac_c_werror_flag" ||
13054 –         test ! -s conftest.err
13055 –       } && test -s conftest$ac_exeext && {
13056 –         test "$cross_compiling" = yes ||
13057 –         $as_test_x conftest$ac_exeext
13058 –       }; then
13059 –  ac_cv_lib_gmpxx_main=yes
13060 – else
13061 –  $as_echo "$as_me: failed program was:" >&5
13062 – sed 's/^/| /' conftest.$ac_ext >&5
7025  
13064 –        ac_cv_lib_gmpxx_main=no
13065 – fi
7026  
13067 – rm -rf conftest.dSYM
13068 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13069 –      conftest$ac_exeext conftest.$ac_ext
13070 – LIBS=$ac_check_lib_save_LIBS
13071 – fi
13072 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
13073 – $as_echo "$ac_cv_lib_gmpxx_main" >&6; }
13074 – if test $ac_cv_lib_gmpxx_main = yes; then
13075 –  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
13076 – fi
7027  
13078 –                fi
7028  
7029 <                if test "$cgal_have_lib" == yes; then
7030 <                        acx_cgal_found=yes
7031 <                fi
13083 <        fi
13084 <        if test "$acx_cgal_found" == yes; then
13085 <                { $as_echo "$as_me:$LINENO: checking for main in -lCore" >&5
13086 < $as_echo_n "checking for main in -lCore... " >&6; }
13087 < if test "${ac_cv_lib_Core_main+set}" = set; then
7029 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU c++" >&5
7030 > $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
7031 > if ${ac_cv_prog_really_gxx+:} false; then :
7032    $as_echo_n "(cached) " >&6
7033   else
13090 –  ac_check_lib_save_LIBS=$LIBS
13091 – LIBS="-lCore  $LIBS"
13092 – cat >conftest.$ac_ext <<_ACEOF
13093 – /* confdefs.h.  */
13094 – _ACEOF
13095 – cat confdefs.h >>conftest.$ac_ext
13096 – cat >>conftest.$ac_ext <<_ACEOF
13097 – /* end confdefs.h.  */
7034  
7035 <
7036 < #ifdef FC_DUMMY_MAIN
7037 < #ifndef FC_DUMMY_MAIN_EQ_F77
7038 < #  ifdef __cplusplus
7039 <     extern "C"
7040 < #  endif
7041 <   int FC_DUMMY_MAIN() { return 1; }
7035 > cat > conftest.cpp <<EOF
7036 > #ifdef __GNUC__
7037 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
7038 >     no;
7039 >  #else
7040 >     yes;
7041 >  #endif
7042   #endif
7043 < #endif
7044 < int
7045 < main ()
7046 < {
13111 < return main ();
13112 <  ;
13113 <  return 0;
13114 < }
13115 < _ACEOF
13116 < rm -f conftest.$ac_objext conftest$ac_exeext
13117 < if { (ac_try="$ac_link"
13118 < case "(($ac_try" in
13119 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13120 <  *) ac_try_echo=$ac_try;;
13121 < esac
13122 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13123 < $as_echo "$ac_try_echo") >&5
13124 <  (eval "$ac_link") 2>conftest.er1
7043 > EOF
7044 > if { ac_try='${CXX-c++} -E conftest.cpp'
7045 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
7046 >  (eval $ac_try) 2>&5
7047    ac_status=$?
7048 <  grep -v '^ *+' conftest.er1 >conftest.err
7049 <  rm -f conftest.er1
7050 <  cat conftest.err >&5
13129 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13130 <  (exit $ac_status); } && {
13131 <         test -z "$ac_c_werror_flag" ||
13132 <         test ! -s conftest.err
13133 <       } && test -s conftest$ac_exeext && {
13134 <         test "$cross_compiling" = yes ||
13135 <         $as_test_x conftest$ac_exeext
13136 <       }; then
13137 <  ac_cv_lib_Core_main=yes
7048 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
7049 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
7050 >  ac_cv_prog_really_gxx=yes
7051   else
7052 <  $as_echo "$as_me: failed program was:" >&5
13140 < sed 's/^/| /' conftest.$ac_ext >&5
13141 <
13142 <        ac_cv_lib_Core_main=no
7052 >  ac_cv_prog_really_gxx=no
7053   fi
7054  
13145 – rm -rf conftest.dSYM
13146 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13147 –      conftest$ac_exeext conftest.$ac_ext
13148 – LIBS=$ac_check_lib_save_LIBS
7055   fi
7056 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
7057 < $as_echo "$ac_cv_lib_Core_main" >&6; }
7058 < if test $ac_cv_lib_Core_main = yes; then
7059 <  CGAL_LIBS="$CGAL_LIBS -lCore"
13154 < fi
7056 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gxx" >&5
7057 > $as_echo "$ac_cv_prog_really_gxx" >&6; }
7058 > if test "$ac_cv_prog_really_gxx" = yes; then
7059 >        :
7060  
7061 <        fi
7061 > else
7062 >        :
7063 >
7064   fi
7065  
7066  
7067 + # Try to determine "good" native compiler flags if none specified on command
7068 + # line
7069 + if test "$ac_test_CXXFLAGS" != "set"; then
7070 +  CXXFLAGS=""
7071 +  case "${host_cpu}-${host_os}" in
7072  
7073 < { $as_echo "$as_me:$LINENO: checking CGAL" >&5
7074 < $as_echo_n "checking CGAL... " >&6; }
7073 >  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
7074 >                    CXXFLAGS="-O2"
7075 >                fi;;
7076 >  sparc-solaris2*) if test "$CXX" = CC; then
7077 >                    CXXFLAGS="-features=extensions -O -dalign"
7078 >                 fi;;
7079 >   rs6000*-aix*)  if test "$CXX" = xlC; then
7080 >                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
7081 >                fi;;
7082 >   powerpc*-aix*)
7083 >        if test "$CXX" = xlC; then
7084 >                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
7085 >                echo "*******************************************************"
7086 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
7087 >                echo "*  recommended that you use                           *"
7088 >                echo "*                                                     *"
7089 >                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
7090 >                echo "*                                 ^^^                 *"
7091 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
7092 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
7093 >                echo "*******************************************************"
7094 >        fi;;
7095 >   *darwin*)
7096 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
7097 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
7098 >        fi
7099 >        if test "$CXX" = icpc; then
7100 >                CXXFLAGS="-O2"
7101 >        fi
7102 >        if test $ac_cv_prog_really_gxx = yes; then
7103 >                CXXFLAGS="-Os"
7104 >        fi;;
7105 >  esac
7106  
7107 +  # use default flags for gcc on all systems
7108 +  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
7109 +     CXXFLAGS="-O2"
7110 +  fi
7111  
7112 +  if test -z "$CXXFLAGS"; then
7113 +        echo ""
7114 +        echo "**********************************************************"
7115 +        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
7116 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7117 +        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
7118 +        echo "**********************************************************"
7119 +        echo ""
7120 +        CXXFLAGS="-O"
7121 +  fi
7122  
7123  
7124  
7125 < if test "$acx_cgal_found" == yes; then
7126 <        { $as_echo "$as_me:$LINENO: result: yes" >&5
7127 < $as_echo "yes" >&6; }
7128 <
7125 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
7126 > $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
7127 > if ${ac_cv_ac_cv_guessed_cxxflags+:} false; then :
7128 >  $as_echo_n "(cached) " >&6
7129   else
7130 <        { $as_echo "$as_me:$LINENO: result: no" >&5
7131 < $as_echo "no" >&6; }
7132 <
7130 >  echo 'void f(){}' > conftest.cpp
7131 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
7132 >        ac_cv_ac_cv_guessed_cxxflags=yes
7133 > else
7134 >        ac_cv_ac_cv_guessed_cxxflags=no
7135   fi
7136 < USE_CGAL=no
13178 < if test "$acx_cgal_found" == yes; then
13179 <        USE_CGAL=yes
7136 > rm -f conftest*
7137  
7138 < cat >>confdefs.h <<\_ACEOF
7139 < #define HAVE_CGAL 1
7140 < _ACEOF
7138 > fi
7139 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cxxflags" >&5
7140 > $as_echo "$ac_cv_ac_cv_guessed_cxxflags" >&6; }
7141 > if test "$ac_cv_ac_cv_guessed_cxxflags" = yes; then
7142 >        :
7143  
7144 + else
7145 +        :
7146  
7147 +        echo ""
7148 +        echo "**********************************************************"
7149 +        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
7150 +        echo "* your compiler.                                         *"
7151 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7152 +        echo "**********************************************************"
7153 +        echo ""
7154 +        CXXFLAGS=""
7155  
7156 + fi
7157  
7158  
7159   fi
7160  
7161 +     ;;
7162 + esac
7163  
7164  
13193 –
7165   # Check whether --enable-doxygen was given.
7166 < if test "${enable_doxygen+set}" = set; then
7166 > if test "${enable_doxygen+set}" = set; then :
7167    enableval=$enable_doxygen;
7168   fi
7169  
7170   # Check whether --enable-dot was given.
7171 < if test "${enable_dot+set}" = set; then
7171 > if test "${enable_dot+set}" = set; then :
7172    enableval=$enable_dot;
7173   fi
7174  
7175   # Check whether --enable-html-docs was given.
7176 < if test "${enable_html_docs+set}" = set; then
7176 > if test "${enable_html_docs+set}" = set; then :
7177    enableval=$enable_html_docs;
7178   else
7179     enable_html_docs=yes
7180   fi
7181  
7182   # Check whether --enable-latex-docs was given.
7183 < if test "${enable_latex_docs+set}" = set; then
7183 > if test "${enable_latex_docs+set}" = set; then :
7184    enableval=$enable_latex_docs;
7185   else
7186     enable_latex_docs=no
# Line 13220 | Line 7191 | set dummy doxygen; ac_word=$2
7191   else
7192          # Extract the first word of "doxygen", so it can be a program name with args.
7193   set dummy doxygen; ac_word=$2
7194 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
7194 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7195   $as_echo_n "checking for $ac_word... " >&6; }
7196 < if test "${ac_cv_path_DOXYGEN+set}" = set; then
7196 > if ${ac_cv_path_DOXYGEN+:} false; then :
7197    $as_echo_n "(cached) " >&6
7198   else
7199    case $DOXYGEN in
# Line 13235 | Line 7206 | do
7206   do
7207    IFS=$as_save_IFS
7208    test -z "$as_dir" && as_dir=.
7209 <  for ac_exec_ext in '' $ac_executable_extensions; do
7209 >    for ac_exec_ext in '' $ac_executable_extensions; do
7210    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7211      ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
7212 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7212 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7213      break 2
7214    fi
7215   done
7216 < done
7216 >  done
7217   IFS=$as_save_IFS
7218  
7219    ;;
# Line 13250 | Line 7221 | if test -n "$DOXYGEN"; then
7221   fi
7222   DOXYGEN=$ac_cv_path_DOXYGEN
7223   if test -n "$DOXYGEN"; then
7224 <  { $as_echo "$as_me:$LINENO: result: $DOXYGEN" >&5
7224 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOXYGEN" >&5
7225   $as_echo "$DOXYGEN" >&6; }
7226   else
7227 <  { $as_echo "$as_me:$LINENO: result: no" >&5
7227 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7228   $as_echo "no" >&6; }
7229   fi
7230  
7231  
7232          if test "x$DOXYGEN" = x; then
7233                  if test "x$enable_doxygen" = xyes; then
7234 <                        { { $as_echo "$as_me:$LINENO: error: could not find doxygen" >&5
13264 < $as_echo "$as_me: error: could not find doxygen" >&2;}
13265 <   { (exit 1); exit 1; }; }
7234 >                        as_fn_error $? "could not find doxygen" "$LINENO" 5
7235                  fi
7236                  enable_doc=no
7237          else
7238                  enable_doc=yes
7239                  # Extract the first word of "dot", so it can be a program name with args.
7240   set dummy dot; ac_word=$2
7241 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
7241 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7242   $as_echo_n "checking for $ac_word... " >&6; }
7243 < if test "${ac_cv_path_DOT+set}" = set; then
7243 > if ${ac_cv_path_DOT+:} false; then :
7244    $as_echo_n "(cached) " >&6
7245   else
7246    case $DOT in
# Line 13284 | Line 7253 | do
7253   do
7254    IFS=$as_save_IFS
7255    test -z "$as_dir" && as_dir=.
7256 <  for ac_exec_ext in '' $ac_executable_extensions; do
7256 >    for ac_exec_ext in '' $ac_executable_extensions; do
7257    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7258      ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
7259 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7259 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7260      break 2
7261    fi
7262   done
7263 < done
7263 >  done
7264   IFS=$as_save_IFS
7265  
7266    ;;
# Line 13299 | Line 7268 | if test -n "$DOT"; then
7268   fi
7269   DOT=$ac_cv_path_DOT
7270   if test -n "$DOT"; then
7271 <  { $as_echo "$as_me:$LINENO: result: $DOT" >&5
7271 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
7272   $as_echo "$DOT" >&6; }
7273   else
7274 <  { $as_echo "$as_me:$LINENO: result: no" >&5
7274 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7275   $as_echo "no" >&6; }
7276   fi
7277  
# Line 13319 | Line 7288 | if test x$DOT = x; then
7288  
7289   if test x$DOT = x; then
7290          if test "x$enable_dot" = xyes; then
7291 <                { { $as_echo "$as_me:$LINENO: error: could not find dot" >&5
13323 < $as_echo "$as_me: error: could not find dot" >&2;}
13324 <   { (exit 1); exit 1; }; }
7291 >                as_fn_error $? "could not find dot" "$LINENO" 5
7292          fi
7293          enable_dot=no
7294   else
7295          enable_dot=yes
7296   fi
13330 –
13331 –
13332 –
7297  
7298  
7299  
# Line 13376 | Line 7340 | _ACEOF
7340      case $ac_val in #(
7341      *${as_nl}*)
7342        case $ac_var in #(
7343 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
7344 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
7343 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
7344 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
7345        esac
7346        case $ac_var in #(
7347        _ | IFS | as_nl) ;; #(
7348        BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
7349 <      *) $as_unset $ac_var ;;
7349 >      *) { eval $ac_var=; unset $ac_var;} ;;
7350        esac ;;
7351      esac
7352    done
# Line 13390 | Line 7354 | $as_echo "$as_me: WARNING: Cache variable $ac_var cont
7354    (set) 2>&1 |
7355      case $as_nl`(ac_space=' '; set) 2>&1` in #(
7356      *${as_nl}ac_space=\ *)
7357 <      # `set' does not quote correctly, so add quotes (double-quote
7358 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7357 >      # `set' does not quote correctly, so add quotes: double-quote
7358 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
7359        sed -n \
7360          "s/'/'\\\\''/g;
7361            s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
# Line 13413 | Line 7377 | if diff "$cache_file" confcache >/dev/null 2>&1; then
7377       :end' >>confcache
7378   if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
7379    if test -w "$cache_file"; then
7380 <    test "x$cache_file" != "x/dev/null" &&
7381 <      { $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
7380 >    if test "x$cache_file" != "x/dev/null"; then
7381 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
7382   $as_echo "$as_me: updating cache $cache_file" >&6;}
7383 <    cat confcache >$cache_file
7383 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
7384 >        cat confcache >"$cache_file"
7385 >      else
7386 >        case $cache_file in #(
7387 >        */* | ?:*)
7388 >          mv -f confcache "$cache_file"$$ &&
7389 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
7390 >        *)
7391 >          mv -f confcache "$cache_file" ;;
7392 >        esac
7393 >      fi
7394 >    fi
7395    else
7396 <    { $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
7396 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
7397   $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
7398    fi
7399   fi
# Line 13432 | Line 7407 | ac_ltlibobjs=
7407  
7408   ac_libobjs=
7409   ac_ltlibobjs=
7410 + U=
7411   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
7412    # 1. Remove the extension, and $U if already installed.
7413    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
7414    ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
7415    # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
7416    #    will be set to the directory where LIBOBJS objects are built.
7417 <  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
7418 <  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
7417 >  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
7418 >  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
7419   done
7420   LIBOBJS=$ac_libobjs
7421  
# Line 13447 | Line 7423 | LTLIBOBJS=$ac_ltlibobjs
7423  
7424  
7425  
7426 < : ${CONFIG_STATUS=./config.status}
7426 > : "${CONFIG_STATUS=./config.status}"
7427   ac_write_fail=0
7428   ac_clean_files_save=$ac_clean_files
7429   ac_clean_files="$ac_clean_files $CONFIG_STATUS"
7430 < { $as_echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
7430 > { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
7431   $as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
7432 < cat >$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7432 > as_write_fail=0
7433 > cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
7434   #! $SHELL
7435   # Generated by $as_me.
7436   # Run this file to recreate the current configuration.
# Line 13463 | Line 7440 | ac_cs_silent=false
7440   debug=false
7441   ac_cs_recheck=false
7442   ac_cs_silent=false
7443 +
7444   SHELL=\${CONFIG_SHELL-$SHELL}
7445 < _ACEOF
7445 > export SHELL
7446 > _ASEOF
7447 > cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
7448 > ## -------------------- ##
7449 > ## M4sh Initialization. ##
7450 > ## -------------------- ##
7451  
13469 – cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
13470 – ## --------------------- ##
13471 – ## M4sh Initialization.  ##
13472 – ## --------------------- ##
13473 –
7452   # Be more Bourne compatible
7453   DUALCASE=1; export DUALCASE # for MKS sh
7454 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
7454 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
7455    emulate sh
7456    NULLCMD=:
7457    # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# Line 13481 | Line 7459 | else
7459    alias -g '${1+"$@"}'='"$@"'
7460    setopt NO_GLOB_SUBST
7461   else
7462 <  case `(set -o) 2>/dev/null` in
7463 <  *posix*) set -o posix ;;
7462 >  case `(set -o) 2>/dev/null` in #(
7463 >  *posix*) :
7464 >    set -o posix ;; #(
7465 >  *) :
7466 >     ;;
7467   esac
13487 –
7468   fi
7469  
7470  
13491 –
13492 –
13493 – # PATH needs CR
13494 – # Avoid depending upon Character Ranges.
13495 – as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13496 – as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13497 – as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13498 – as_cr_digits='0123456789'
13499 – as_cr_alnum=$as_cr_Letters$as_cr_digits
13500 –
7471   as_nl='
7472   '
7473   export as_nl
# Line 13505 | Line 7475 | as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
7475   as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
7476   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
7477   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
7478 < if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
7478 > # Prefer a ksh shell builtin over an external printf program on Solaris,
7479 > # but without wasting forks for bash or zsh.
7480 > if test -z "$BASH_VERSION$ZSH_VERSION" \
7481 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
7482 >  as_echo='print -r --'
7483 >  as_echo_n='print -rn --'
7484 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
7485    as_echo='printf %s\n'
7486    as_echo_n='printf %s'
7487   else
# Line 13516 | Line 7492 | else
7492      as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
7493      as_echo_n_body='eval
7494        arg=$1;
7495 <      case $arg in
7495 >      case $arg in #(
7496        *"$as_nl"*)
7497          expr "X$arg" : "X\\(.*\\)$as_nl";
7498          arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
# Line 13539 | Line 7515 | fi
7515    }
7516   fi
7517  
13542 – # Support unset when possible.
13543 – if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13544 –  as_unset=unset
13545 – else
13546 –  as_unset=false
13547 – fi
7518  
13549 –
7519   # IFS
7520   # We need space, tab and new line, in precisely that order.  Quoting is
7521   # there to prevent editors from complaining about space-tab.
# Line 13555 | Line 7524 | IFS=" ""       $as_nl"
7524   IFS=" ""        $as_nl"
7525  
7526   # Find who we are.  Look in the path if we contain no directory separator.
7527 < case $0 in
7527 > as_myself=
7528 > case $0 in #((
7529    *[\\/]* ) as_myself=$0 ;;
7530    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7531   for as_dir in $PATH
7532   do
7533    IFS=$as_save_IFS
7534    test -z "$as_dir" && as_dir=.
7535 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7536 < done
7535 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7536 >  done
7537   IFS=$as_save_IFS
7538  
7539       ;;
# Line 13575 | Line 7545 | if test ! -f "$as_myself"; then
7545   fi
7546   if test ! -f "$as_myself"; then
7547    $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
7548 <  { (exit 1); exit 1; }
7548 >  exit 1
7549   fi
7550  
7551 < # Work around bugs in pre-3.0 UWIN ksh.
7552 < for as_var in ENV MAIL MAILPATH
7553 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
7551 > # Unset variables that we do not need and which cause bugs (e.g. in
7552 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
7553 > # suppresses any "Segmentation fault" message there.  '((' could
7554 > # trigger a bug in pdksh 5.2.14.
7555 > for as_var in BASH_ENV ENV MAIL MAILPATH
7556 > do eval test x\${$as_var+set} = xset \
7557 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
7558   done
7559   PS1='$ '
7560   PS2='> '
# Line 13592 | Line 7566 | export LANGUAGE
7566   LANGUAGE=C
7567   export LANGUAGE
7568  
7569 < # Required to use basename.
7569 > # CDPATH.
7570 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
7571 >
7572 >
7573 > # as_fn_error STATUS ERROR [LINENO LOG_FD]
7574 > # ----------------------------------------
7575 > # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
7576 > # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
7577 > # script with STATUS, using 1 if that was 0.
7578 > as_fn_error ()
7579 > {
7580 >  as_status=$1; test $as_status -eq 0 && as_status=1
7581 >  if test "$4"; then
7582 >    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
7583 >    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
7584 >  fi
7585 >  $as_echo "$as_me: error: $2" >&2
7586 >  as_fn_exit $as_status
7587 > } # as_fn_error
7588 >
7589 >
7590 > # as_fn_set_status STATUS
7591 > # -----------------------
7592 > # Set $? to STATUS, without forking.
7593 > as_fn_set_status ()
7594 > {
7595 >  return $1
7596 > } # as_fn_set_status
7597 >
7598 > # as_fn_exit STATUS
7599 > # -----------------
7600 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
7601 > as_fn_exit ()
7602 > {
7603 >  set +e
7604 >  as_fn_set_status $1
7605 >  exit $1
7606 > } # as_fn_exit
7607 >
7608 > # as_fn_unset VAR
7609 > # ---------------
7610 > # Portably unset VAR.
7611 > as_fn_unset ()
7612 > {
7613 >  { eval $1=; unset $1;}
7614 > }
7615 > as_unset=as_fn_unset
7616 > # as_fn_append VAR VALUE
7617 > # ----------------------
7618 > # Append the text in VALUE to the end of the definition contained in VAR. Take
7619 > # advantage of any shell optimizations that allow amortized linear growth over
7620 > # repeated appends, instead of the typical quadratic growth present in naive
7621 > # implementations.
7622 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
7623 >  eval 'as_fn_append ()
7624 >  {
7625 >    eval $1+=\$2
7626 >  }'
7627 > else
7628 >  as_fn_append ()
7629 >  {
7630 >    eval $1=\$$1\$2
7631 >  }
7632 > fi # as_fn_append
7633 >
7634 > # as_fn_arith ARG...
7635 > # ------------------
7636 > # Perform arithmetic evaluation on the ARGs, and store the result in the
7637 > # global $as_val. Take advantage of shells that can avoid forks. The arguments
7638 > # must be portable across $(()) and expr.
7639 > if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
7640 >  eval 'as_fn_arith ()
7641 >  {
7642 >    as_val=$(( $* ))
7643 >  }'
7644 > else
7645 >  as_fn_arith ()
7646 >  {
7647 >    as_val=`expr "$@" || test $? -eq 1`
7648 >  }
7649 > fi # as_fn_arith
7650 >
7651 >
7652   if expr a : '\(a\)' >/dev/null 2>&1 &&
7653     test "X`expr 00001 : '.*\(...\)'`" = X001; then
7654    as_expr=expr
# Line 13606 | Line 7662 | fi
7662    as_basename=false
7663   fi
7664  
7665 + if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
7666 +  as_dirname=dirname
7667 + else
7668 +  as_dirname=false
7669 + fi
7670  
13610 – # Name of the executable.
7671   as_me=`$as_basename -- "$0" ||
7672   $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
7673           X"$0" : 'X\(//\)$' \| \
# Line 13627 | Line 7687 | $as_echo X/"$0" |
7687            }
7688            s/.*/./; q'`
7689  
7690 < # CDPATH.
7691 < $as_unset CDPATH
7690 > # Avoid depending upon Character Ranges.
7691 > as_cr_letters='abcdefghijklmnopqrstuvwxyz'
7692 > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
7693 > as_cr_Letters=$as_cr_letters$as_cr_LETTERS
7694 > as_cr_digits='0123456789'
7695 > as_cr_alnum=$as_cr_Letters$as_cr_digits
7696  
13633 –
13634 –
13635 –  as_lineno_1=$LINENO
13636 –  as_lineno_2=$LINENO
13637 –  test "x$as_lineno_1" != "x$as_lineno_2" &&
13638 –  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
13639 –
13640 –  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13641 –  # uniformly replaced by the line number.  The first 'sed' inserts a
13642 –  # line-number line after each line using $LINENO; the second 'sed'
13643 –  # does the real work.  The second script uses 'N' to pair each
13644 –  # line-number line with the line containing $LINENO, and appends
13645 –  # trailing '-' during substitution so that $LINENO is not a special
13646 –  # case at line end.
13647 –  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13648 –  # scripts with optimization help from Paolo Bonzini.  Blame Lee
13649 –  # E. McMahon (1931-1989) for sed's syntax.  :-)
13650 –  sed -n '
13651 –    p
13652 –    /[$]LINENO/=
13653 –  ' <$as_myself |
13654 –    sed '
13655 –      s/[$]LINENO.*/&-/
13656 –      t lineno
13657 –      b
13658 –      :lineno
13659 –      N
13660 –      :loop
13661 –      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
13662 –      t loop
13663 –      s/-\n.*//
13664 –    ' >$as_me.lineno &&
13665 –  chmod +x "$as_me.lineno" ||
13666 –    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
13667 –   { (exit 1); exit 1; }; }
13668 –
13669 –  # Don't try to exec as it changes $[0], causing all sort of problems
13670 –  # (the dirname of $[0] is not the place where we might find the
13671 –  # original and so on.  Autoconf is especially sensitive to this).
13672 –  . "./$as_me.lineno"
13673 –  # Exit status is that of the last command.
13674 –  exit
13675 – }
13676 –
13677 –
13678 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
13679 –  as_dirname=dirname
13680 – else
13681 –  as_dirname=false
13682 – fi
13683 –
7697   ECHO_C= ECHO_N= ECHO_T=
7698 < case `echo -n x` in
7698 > case `echo -n x` in #(((((
7699   -n*)
7700 <  case `echo 'x\c'` in
7700 >  case `echo 'xy\c'` in
7701    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
7702 <  *)   ECHO_C='\c';;
7702 >  xy)  ECHO_C='\c';;
7703 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
7704 >       ECHO_T=' ';;
7705    esac;;
7706   *)
7707    ECHO_N='-n';;
7708   esac
13694 – if expr a : '\(a\)' >/dev/null 2>&1 &&
13695 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
13696 –  as_expr=expr
13697 – else
13698 –  as_expr=false
13699 – fi
7709  
7710   rm -f conf$$ conf$$.exe conf$$.file
7711   if test -d conf$$.dir; then
# Line 13725 | Line 7734 | rmdir conf$$.dir 2>/dev/null
7734   rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
7735   rmdir conf$$.dir 2>/dev/null
7736  
7737 +
7738 + # as_fn_mkdir_p
7739 + # -------------
7740 + # Create "$as_dir" as a directory, including parents if necessary.
7741 + as_fn_mkdir_p ()
7742 + {
7743 +
7744 +  case $as_dir in #(
7745 +  -*) as_dir=./$as_dir;;
7746 +  esac
7747 +  test -d "$as_dir" || eval $as_mkdir_p || {
7748 +    as_dirs=
7749 +    while :; do
7750 +      case $as_dir in #(
7751 +      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
7752 +      *) as_qdir=$as_dir;;
7753 +      esac
7754 +      as_dirs="'$as_qdir' $as_dirs"
7755 +      as_dir=`$as_dirname -- "$as_dir" ||
7756 + $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
7757 +         X"$as_dir" : 'X\(//\)[^/]' \| \
7758 +         X"$as_dir" : 'X\(//\)$' \| \
7759 +         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
7760 + $as_echo X"$as_dir" |
7761 +    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
7762 +            s//\1/
7763 +            q
7764 +          }
7765 +          /^X\(\/\/\)[^/].*/{
7766 +            s//\1/
7767 +            q
7768 +          }
7769 +          /^X\(\/\/\)$/{
7770 +            s//\1/
7771 +            q
7772 +          }
7773 +          /^X\(\/\).*/{
7774 +            s//\1/
7775 +            q
7776 +          }
7777 +          s/.*/./; q'`
7778 +      test -d "$as_dir" && break
7779 +    done
7780 +    test -z "$as_dirs" || eval "mkdir $as_dirs"
7781 +  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
7782 +
7783 +
7784 + } # as_fn_mkdir_p
7785   if mkdir -p . 2>/dev/null; then
7786 <  as_mkdir_p=:
7786 >  as_mkdir_p='mkdir -p "$as_dir"'
7787   else
7788    test -d ./-p && rmdir ./-p
7789    as_mkdir_p=false
# Line 13745 | Line 7802 | else
7802        if test -d "$1"; then
7803          test -d "$1/.";
7804        else
7805 <        case $1 in
7805 >        case $1 in #(
7806          -*)set "./$1";;
7807          esac;
7808 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
7808 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
7809          ???[sx]*):;;*)false;;esac;fi
7810      '\'' sh
7811    '
# Line 13763 | Line 7820 | exec 6>&1
7820  
7821  
7822   exec 6>&1
7823 + ## ----------------------------------- ##
7824 + ## Main body of $CONFIG_STATUS script. ##
7825 + ## ----------------------------------- ##
7826 + _ASEOF
7827 + test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
7828  
7829 < # Save the log message, to keep $[0] and so on meaningful, and to
7829 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7830 > # Save the log message, to keep $0 and so on meaningful, and to
7831   # report actual input values of CONFIG_FILES etc. instead of their
7832   # values after options handling.
7833   ac_log="
7834 < This file was extended by OOPSE $as_me 4.0, which was
7835 < generated by GNU Autoconf 2.62.  Invocation command line was
7834 > This file was extended by OpenMD $as_me 1.0, which was
7835 > generated by GNU Autoconf 2.68.  Invocation command line was
7836  
7837    CONFIG_FILES    = $CONFIG_FILES
7838    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 13782 | Line 7845 | _ACEOF
7845  
7846   _ACEOF
7847  
7848 + case $ac_config_files in *"
7849 + "*) set x $ac_config_files; shift; ac_config_files=$*;;
7850 + esac
7851 +
7852 + case $ac_config_headers in *"
7853 + "*) set x $ac_config_headers; shift; ac_config_headers=$*;;
7854 + esac
7855 +
7856 +
7857   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7858   # Files that config.status was made for.
7859   config_files="$ac_config_files"
# Line 13791 | Line 7863 | ac_cs_usage="\
7863  
7864   cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7865   ac_cs_usage="\
7866 < \`$as_me' instantiates files from templates according to the
7867 < current configuration.
7866 > \`$as_me' instantiates files and other configuration actions
7867 > from templates according to the current configuration.  Unless the files
7868 > and actions are specified as TAGs, all are instantiated by default.
7869  
7870 < Usage: $0 [OPTIONS] [FILE]...
7870 > Usage: $0 [OPTION]... [TAG]...
7871  
7872    -h, --help       print this help, then exit
7873    -V, --version    print version number and configuration settings, then exit
7874 <  -q, --quiet      do not print progress messages
7874 >      --config     print configuration, then exit
7875 >  -q, --quiet, --silent
7876 >                   do not print progress messages
7877    -d, --debug      don't remove temporary files
7878        --recheck    update $as_me by reconfiguring in the same conditions
7879 <  --file=FILE[:TEMPLATE]
7879 >      --file=FILE[:TEMPLATE]
7880                     instantiate the configuration file FILE
7881 <  --header=FILE[:TEMPLATE]
7881 >      --header=FILE[:TEMPLATE]
7882                     instantiate the configuration header FILE
7883  
7884   Configuration files:
# Line 13812 | Line 7887 | $config_headers
7887   Configuration headers:
7888   $config_headers
7889  
7890 < Report bugs to <bug-autoconf@gnu.org>."
7890 > Report bugs to <gezelter@nd.edu>."
7891  
7892   _ACEOF
7893   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7894 + ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
7895   ac_cs_version="\\
7896 < OOPSE config.status 4.0
7897 < configured by $0, generated by GNU Autoconf 2.62,
7898 <  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
7896 > OpenMD config.status 1.0
7897 > configured by $0, generated by GNU Autoconf 2.68,
7898 >  with options \\"\$ac_cs_config\\"
7899  
7900 < Copyright (C) 2008 Free Software Foundation, Inc.
7900 > Copyright (C) 2010 Free Software Foundation, Inc.
7901   This config.status script is free software; the Free Software Foundation
7902   gives unlimited permission to copy, distribute and modify it."
7903  
# Line 13837 | Line 7913 | do
7913   while test $# != 0
7914   do
7915    case $1 in
7916 <  --*=*)
7916 >  --*=?*)
7917      ac_option=`expr "X$1" : 'X\([^=]*\)='`
7918      ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
7919      ac_shift=:
7920      ;;
7921 +  --*=)
7922 +    ac_option=`expr "X$1" : 'X\([^=]*\)='`
7923 +    ac_optarg=
7924 +    ac_shift=:
7925 +    ;;
7926    *)
7927      ac_option=$1
7928      ac_optarg=$2
# Line 13855 | Line 7936 | do
7936      ac_cs_recheck=: ;;
7937    --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
7938      $as_echo "$ac_cs_version"; exit ;;
7939 +  --config | --confi | --conf | --con | --co | --c )
7940 +    $as_echo "$ac_cs_config"; exit ;;
7941    --debug | --debu | --deb | --de | --d | -d )
7942      debug=: ;;
7943    --file | --fil | --fi | --f )
7944      $ac_shift
7945      case $ac_optarg in
7946      *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7947 +    '') as_fn_error $? "missing file argument" ;;
7948      esac
7949 <    CONFIG_FILES="$CONFIG_FILES '$ac_optarg'"
7949 >    as_fn_append CONFIG_FILES " '$ac_optarg'"
7950      ac_need_defaults=false;;
7951    --header | --heade | --head | --hea )
7952      $ac_shift
7953      case $ac_optarg in
7954      *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7955      esac
7956 <    CONFIG_HEADERS="$CONFIG_HEADERS '$ac_optarg'"
7956 >    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
7957      ac_need_defaults=false;;
7958    --he | --h)
7959      # Conflict between --help and --header
7960 <    { $as_echo "$as_me: error: ambiguous option: $1
7961 < Try \`$0 --help' for more information." >&2
13878 <   { (exit 1); exit 1; }; };;
7960 >    as_fn_error $? "ambiguous option: \`$1'
7961 > Try \`$0 --help' for more information.";;
7962    --help | --hel | -h )
7963      $as_echo "$ac_cs_usage"; exit ;;
7964    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
# Line 13883 | Line 7966 | Try \`$0 --help' for more information." >&2
7966      ac_cs_silent=: ;;
7967  
7968    # This is an error.
7969 <  -*) { $as_echo "$as_me: error: unrecognized option: $1
7970 < Try \`$0 --help' for more information." >&2
13888 <   { (exit 1); exit 1; }; } ;;
7969 >  -*) as_fn_error $? "unrecognized option: \`$1'
7970 > Try \`$0 --help' for more information." ;;
7971  
7972 <  *) ac_config_targets="$ac_config_targets $1"
7972 >  *) as_fn_append ac_config_targets " $1"
7973       ac_need_defaults=false ;;
7974  
7975    esac
# Line 13941 | Line 8023 | do
8023      "src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
8024      "scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
8025  
8026 <  *) { { $as_echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13945 < $as_echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13946 <   { (exit 1); exit 1; }; };;
8026 >  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
8027    esac
8028   done
8029  
# Line 13965 | Line 8045 | $debug ||
8045   # after its creation but before its name has been assigned to `$tmp'.
8046   $debug ||
8047   {
8048 <  tmp=
8048 >  tmp= ac_tmp=
8049    trap 'exit_status=$?
8050 <  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
8050 >  : "${ac_tmp:=$tmp}"
8051 >  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
8052   ' 0
8053 <  trap '{ (exit 1); exit 1; }' 1 2 13 15
8053 >  trap 'as_fn_exit 1' 1 2 13 15
8054   }
8055   # Create a (secure) tmp directory for tmp files.
8056  
8057   {
8058    tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
8059 <  test -n "$tmp" && test -d "$tmp"
8059 >  test -d "$tmp"
8060   }  ||
8061   {
8062    tmp=./conf$$-$RANDOM
8063    (umask 077 && mkdir "$tmp")
8064 < } ||
8065 < {
13985 <   $as_echo "$as_me: cannot create a temporary directory in ." >&2
13986 <   { (exit 1); exit 1; }
13987 < }
8064 > } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
8065 > ac_tmp=$tmp
8066  
8067   # Set up the scripts for CONFIG_FILES section.
8068   # No need to generate them if there are no CONFIG_FILES.
# Line 13992 | Line 8070 | if test -n "$CONFIG_FILES"; then
8070   if test -n "$CONFIG_FILES"; then
8071  
8072  
8073 < ac_cr='
8074 < '
8073 > ac_cr=`echo X | tr X '\015'`
8074 > # On cygwin, bash can eat \r inside `` if the user requested igncr.
8075 > # But we know of no other shell where ac_cr would be empty at this
8076 > # point, so we can use a bashism as a fallback.
8077 > if test "x$ac_cr" = x; then
8078 >  eval ac_cr=\$\'\\r\'
8079 > fi
8080   ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
8081   if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
8082    ac_cs_awk_cr='\\r'
# Line 14001 | Line 8084 | fi
8084    ac_cs_awk_cr=$ac_cr
8085   fi
8086  
8087 < echo 'BEGIN {' >"$tmp/subs1.awk" &&
8087 > echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
8088   _ACEOF
8089  
8090  
# Line 14010 | Line 8093 | _ACEOF
8093    echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
8094    echo "_ACEOF"
8095   } >conf$$subs.sh ||
8096 <  { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
8097 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14015 <   { (exit 1); exit 1; }; }
14016 < ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'`
8096 >  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8097 > ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
8098   ac_delim='%!_!# '
8099   for ac_last_try in false false false false false :; do
8100    . ./conf$$subs.sh ||
8101 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14021 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14022 <   { (exit 1); exit 1; }; }
8101 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8102  
8103 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` = $ac_delim_num; then
8103 >  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
8104 >  if test $ac_delim_n = $ac_delim_num; then
8105      break
8106    elif $ac_last_try; then
8107 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14028 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14029 <   { (exit 1); exit 1; }; }
8107 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8108    else
8109      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
8110    fi
# Line 14034 | Line 8112 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8112   rm -f conf$$subs.sh
8113  
8114   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8115 < cat >>"\$tmp/subs1.awk" <<\\_ACAWK &&
8115 > cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
8116   _ACEOF
8117   sed -n '
8118   h
# Line 14048 | Line 8126 | h
8126   t delim
8127   :nl
8128   h
8129 < s/\(.\{148\}\).*/\1/
8129 > s/\(.\{148\}\)..*/\1/
8130   t more1
8131   s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
8132   p
# Line 14062 | Line 8140 | h
8140   t nl
8141   :delim
8142   h
8143 < s/\(.\{148\}\).*/\1/
8143 > s/\(.\{148\}\)..*/\1/
8144   t more2
8145   s/["\\]/\\&/g; s/^/"/; s/$/"/
8146   p
# Line 14082 | Line 8160 | _ACAWK
8160   rm -f conf$$subs.awk
8161   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8162   _ACAWK
8163 < cat >>"\$tmp/subs1.awk" <<_ACAWK &&
8163 > cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
8164    for (key in S) S_is_set[key] = 1
8165    FS = ""
8166  
# Line 14114 | Line 8192 | else
8192    sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
8193   else
8194    cat
8195 < fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
8196 <  || { { $as_echo "$as_me:$LINENO: error: could not setup config files machinery" >&5
14119 < $as_echo "$as_me: error: could not setup config files machinery" >&2;}
14120 <   { (exit 1); exit 1; }; }
8195 > fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
8196 >  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
8197   _ACEOF
8198  
8199 < # VPATH may cause trouble with some makes, so we remove $(srcdir),
8200 < # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
8199 > # VPATH may cause trouble with some makes, so we remove sole $(srcdir),
8200 > # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
8201   # trailing colons and then remove the whole line if VPATH becomes empty
8202   # (actually we leave an empty line to preserve line numbers).
8203   if test "x$srcdir" = x.; then
8204 <  ac_vpsub='/^[  ]*VPATH[        ]*=/{
8205 < s/:*\$(srcdir):*/:/
8206 < s/:*\${srcdir}:*/:/
8207 < s/:*@srcdir@:*/:/
8208 < s/^\([^=]*=[     ]*\):*/\1/
8204 >  ac_vpsub='/^[  ]*VPATH[        ]*=[    ]*/{
8205 > h
8206 > s///
8207 > s/^/:/
8208 > s/[      ]*$/:/
8209 > s/:\$(srcdir):/:/g
8210 > s/:\${srcdir}:/:/g
8211 > s/:@srcdir@:/:/g
8212 > s/^:*//
8213   s/:*$//
8214 + x
8215 + s/\(=[   ]*\).*/\1/
8216 + G
8217 + s/\n//
8218   s/^[^=]*=[       ]*$//
8219   }'
8220   fi
# Line 14142 | Line 8226 | if test -n "$CONFIG_HEADERS"; then
8226   # No need to generate them if there are no CONFIG_HEADERS.
8227   # This happens for instance with `./config.status Makefile'.
8228   if test -n "$CONFIG_HEADERS"; then
8229 < cat >"$tmp/defines.awk" <<\_ACAWK ||
8229 > cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
8230   BEGIN {
8231   _ACEOF
8232  
# Line 14154 | Line 8238 | for ac_last_try in false false :; do
8238   # handling of long lines.
8239   ac_delim='%!_!# '
8240   for ac_last_try in false false :; do
8241 <  ac_t=`sed -n "/$ac_delim/p" confdefs.h`
8242 <  if test -z "$ac_t"; then
8241 >  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
8242 >  if test -z "$ac_tt"; then
8243      break
8244    elif $ac_last_try; then
8245 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_HEADERS" >&5
14162 < $as_echo "$as_me: error: could not make $CONFIG_HEADERS" >&2;}
14163 <   { (exit 1); exit 1; }; }
8245 >    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
8246    else
8247      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
8248    fi
# Line 14226 | Line 8308 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8308    }
8309    split(mac1, mac2, "(") #)
8310    macro = mac2[1]
8311 +  prefix = substr(line, 1, index(line, defundef) - 1)
8312    if (D_is_set[macro]) {
8313      # Preserve the white space surrounding the "#".
14231 –    prefix = substr(line, 1, index(line, defundef) - 1)
8314      print prefix "define", macro P[macro] D[macro]
8315      next
8316    } else {
# Line 14236 | Line 8318 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8318      # in the case of _POSIX_SOURCE, which is predefined and required
8319      # on some systems where configure will not decide to define it.
8320      if (defundef == "undef") {
8321 <      print "/*", line, "*/"
8321 >      print "/*", prefix defundef, macro, "*/"
8322        next
8323      }
8324    }
# Line 14245 | Line 8327 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8327   _ACAWK
8328   _ACEOF
8329   cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8330 <  { { $as_echo "$as_me:$LINENO: error: could not setup config headers machinery" >&5
14249 < $as_echo "$as_me: error: could not setup config headers machinery" >&2;}
14250 <   { (exit 1); exit 1; }; }
8330 >  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
8331   fi # test -n "$CONFIG_HEADERS"
8332  
8333  
# Line 14260 | Line 8340 | do
8340    esac
8341    case $ac_mode$ac_tag in
8342    :[FHL]*:*);;
8343 <  :L* | :C*:*) { { $as_echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
14264 < $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
14265 <   { (exit 1); exit 1; }; };;
8343 >  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
8344    :[FH]-) ac_tag=-:-;;
8345    :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
8346    esac
# Line 14281 | Line 8359 | $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
8359      for ac_f
8360      do
8361        case $ac_f in
8362 <      -) ac_f="$tmp/stdin";;
8362 >      -) ac_f="$ac_tmp/stdin";;
8363        *) # Look for the file first in the build tree, then in the source tree
8364           # (if the path is not absolute).  The absolute path cannot be DOS-style,
8365           # because $ac_f cannot contain `:'.
# Line 14290 | Line 8368 | $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
8368             [\\/$]*) false;;
8369             *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
8370             esac ||
8371 <           { { $as_echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
14294 < $as_echo "$as_me: error: cannot find input file: $ac_f" >&2;}
14295 <   { (exit 1); exit 1; }; };;
8371 >           as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
8372        esac
8373        case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
8374 <      ac_file_inputs="$ac_file_inputs '$ac_f'"
8374 >      as_fn_append ac_file_inputs " '$ac_f'"
8375      done
8376  
8377      # Let's still pretend it is `configure' which instantiates (i.e., don't
# Line 14306 | Line 8382 | $as_echo "$as_me: error: cannot find input file: $ac_f
8382          `' by configure.'
8383      if test x"$ac_file" != x-; then
8384        configure_input="$ac_file.  $configure_input"
8385 <      { $as_echo "$as_me:$LINENO: creating $ac_file" >&5
8385 >      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
8386   $as_echo "$as_me: creating $ac_file" >&6;}
8387      fi
8388      # Neutralize special characters interpreted by sed in replacement strings.
# Line 14318 | Line 8394 | $as_echo "$as_me: creating $ac_file" >&6;}
8394      esac
8395  
8396      case $ac_tag in
8397 <    *:-:* | *:-) cat >"$tmp/stdin" \
8398 <      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14323 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14324 <   { (exit 1); exit 1; }; } ;;
8397 >    *:-:* | *:-) cat >"$ac_tmp/stdin" \
8398 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
8399      esac
8400      ;;
8401    esac
# Line 14332 | Line 8406 | $as_echo X"$ac_file" |
8406           X"$ac_file" : 'X\(//\)$' \| \
8407           X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
8408   $as_echo X"$ac_file" |
14335 –    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14336 –            s//\1/
14337 –            q
14338 –          }
14339 –          /^X\(\/\/\)[^/].*/{
14340 –            s//\1/
14341 –            q
14342 –          }
14343 –          /^X\(\/\/\)$/{
14344 –            s//\1/
14345 –            q
14346 –          }
14347 –          /^X\(\/\).*/{
14348 –            s//\1/
14349 –            q
14350 –          }
14351 –          s/.*/./; q'`
14352 –  { as_dir="$ac_dir"
14353 –  case $as_dir in #(
14354 –  -*) as_dir=./$as_dir;;
14355 –  esac
14356 –  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
14357 –    as_dirs=
14358 –    while :; do
14359 –      case $as_dir in #(
14360 –      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
14361 –      *) as_qdir=$as_dir;;
14362 –      esac
14363 –      as_dirs="'$as_qdir' $as_dirs"
14364 –      as_dir=`$as_dirname -- "$as_dir" ||
14365 – $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14366 –         X"$as_dir" : 'X\(//\)[^/]' \| \
14367 –         X"$as_dir" : 'X\(//\)$' \| \
14368 –         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
14369 – $as_echo X"$as_dir" |
8409      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
8410              s//\1/
8411              q
# Line 14384 | Line 8423 | $as_echo X"$as_dir" |
8423              q
8424            }
8425            s/.*/./; q'`
8426 <      test -d "$as_dir" && break
14388 <    done
14389 <    test -z "$as_dirs" || eval "mkdir $as_dirs"
14390 <  } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
14391 < $as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
14392 <   { (exit 1); exit 1; }; }; }
8426 >  as_dir="$ac_dir"; as_fn_mkdir_p
8427    ac_builddir=.
8428  
8429   case "$ac_dir" in
# Line 14441 | Line 8475 | ac_datarootdir_hack=; ac_datarootdir_seen=
8475   # If the template does not know about datarootdir, expand it.
8476   # FIXME: This hack should be removed a few years after 2.60.
8477   ac_datarootdir_hack=; ac_datarootdir_seen=
14444 –
8478   ac_sed_dataroot='
8479   /datarootdir/ {
8480    p
# Line 14451 | Line 8484 | ac_sed_dataroot='
8484   /@docdir@/p
8485   /@infodir@/p
8486   /@localedir@/p
8487 < /@mandir@/p
14455 < '
8487 > /@mandir@/p'
8488   case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
8489   *datarootdir*) ac_datarootdir_seen=yes;;
8490   *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
8491 <  { $as_echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8491 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8492   $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
8493   _ACEOF
8494   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Line 14466 | Line 8498 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8498    s&@infodir@&$infodir&g
8499    s&@localedir@&$localedir&g
8500    s&@mandir@&$mandir&g
8501 <    s&\\\${datarootdir}&$datarootdir&g' ;;
8501 >  s&\\\${datarootdir}&$datarootdir&g' ;;
8502   esac
8503   _ACEOF
8504  
# Line 14493 | Line 8525 | $ac_datarootdir_hack
8525   s&@INSTALL@&$ac_INSTALL&;t t
8526   $ac_datarootdir_hack
8527   "
8528 < eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
8529 <  || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14498 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14499 <   { (exit 1); exit 1; }; }
8528 > eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
8529 >  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8530  
8531   test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
8532 <  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
8533 <  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
8534 <  { $as_echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8535 < which seems to be undefined.  Please make sure it is defined." >&5
8532 >  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
8533 >  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' \
8534 >      "$ac_tmp/out"`; test -z "$ac_out"; } &&
8535 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8536 > which seems to be undefined.  Please make sure it is defined" >&5
8537   $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8538 < which seems to be undefined.  Please make sure it is defined." >&2;}
8538 > which seems to be undefined.  Please make sure it is defined" >&2;}
8539  
8540 <  rm -f "$tmp/stdin"
8540 >  rm -f "$ac_tmp/stdin"
8541    case $ac_file in
8542 <  -) cat "$tmp/out" && rm -f "$tmp/out";;
8543 <  *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
8542 >  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
8543 >  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
8544    esac \
8545 <  || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14515 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14516 <   { (exit 1); exit 1; }; }
8545 >  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8546   ;;
8547    :H)
8548    #
# Line 14522 | Line 8551 | $as_echo "$as_me: error: could not create $ac_file" >&
8551    if test x"$ac_file" != x-; then
8552      {
8553        $as_echo "/* $configure_input  */" \
8554 <      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
8555 <    } >"$tmp/config.h" \
8556 <      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
8557 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
8558 <   { (exit 1); exit 1; }; }
14530 <    if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
14531 <      { $as_echo "$as_me:$LINENO: $ac_file is unchanged" >&5
8554 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
8555 >    } >"$ac_tmp/config.h" \
8556 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8557 >    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
8558 >      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
8559   $as_echo "$as_me: $ac_file is unchanged" >&6;}
8560      else
8561        rm -f "$ac_file"
8562 <      mv "$tmp/config.h" "$ac_file" \
8563 <        || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14537 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14538 <   { (exit 1); exit 1; }; }
8562 >      mv "$ac_tmp/config.h" "$ac_file" \
8563 >        || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8564      fi
8565    else
8566      $as_echo "/* $configure_input  */" \
8567 <      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
8568 <      || { { $as_echo "$as_me:$LINENO: error: could not create -" >&5
14544 < $as_echo "$as_me: error: could not create -" >&2;}
14545 <   { (exit 1); exit 1; }; }
8567 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
8568 >      || as_fn_error $? "could not create -" "$LINENO" 5
8569    fi
8570   ;;
8571  
# Line 14562 | Line 8585 | done # for ac_tag
8585   done # for ac_tag
8586  
8587  
8588 < { (exit 0); exit 0; }
8588 > as_fn_exit 0
8589   _ACEOF
14567 – chmod +x $CONFIG_STATUS
8590   ac_clean_files=$ac_clean_files_save
8591  
8592   test $ac_write_fail = 0 ||
8593 <  { { $as_echo "$as_me:$LINENO: error: write failure creating $CONFIG_STATUS" >&5
14572 < $as_echo "$as_me: error: write failure creating $CONFIG_STATUS" >&2;}
14573 <   { (exit 1); exit 1; }; }
8593 >  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
8594  
8595  
8596   # configure is writing to config.log, and then calls config.status.
# Line 14591 | Line 8611 | if test "$no_create" != yes; then
8611    exec 5>>config.log
8612    # Use ||, not &&, to avoid exiting from the if with $? = 1, which
8613    # would make configure fail if this is the last instruction.
8614 <  $ac_cs_success || { (exit 1); exit 1; }
8614 >  $ac_cs_success || as_fn_exit 1
8615   fi
8616   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
8617 <  { $as_echo "$as_me:$LINENO: WARNING: Unrecognized options: $ac_unrecognized_opts" >&5
8618 < $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2;}
8617 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
8618 > $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
8619   fi
8620  

Diff Legend

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