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 1300 by gezelter, Mon Sep 29 13:54:18 2008 UTC vs.
branches/development/configure (file contents), Revision 1632 by gezelter, Wed Sep 14 21:44:08 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 2.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='2.0'
564 > PACKAGE_STRING='OpenMD 2.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
682 < 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 > AR
636 > INSTALL_DATA
637 > INSTALL_SCRIPT
638 > INSTALL_PROGRAM
639 > PERL_SHEBANG
640 > PERLINTERP
641 > RANLIB
642 > SET_MAKE
643 > LN_S
644 > EGREP
645 > GREP
646 > CPP
647   USE_MPI
648 < CXX
649 < CXXFLAGS
650 < LDFLAGS
651 < CPPFLAGS
709 < ac_ct_CXX
710 < EXEEXT
711 < OBJEXT
712 < CC
713 < CFLAGS
648 > MPICC
649 > MPILIBS
650 > MPICXX
651 > LIBDL
652   ac_ct_CC
653 < FC
654 < FCFLAGS
655 < ac_ct_FC
656 < CPP
657 < GREP
658 < EGREP
659 < LN_S
660 < SET_MAKE
661 < RANLIB
662 < PERLINTERP
663 < PERL_SHEBANG
664 < INSTALL_PROGRAM
665 < INSTALL_SCRIPT
666 < INSTALL_DATA
667 < AR
668 < PS
669 < FCFLAGS_F90
670 < FCFLAGS_SRCEXT
671 < PREPDEFFLAG
672 < FCLIBS
673 < FC_FUNC
674 < FC_FUNC_
675 < MOD
676 < F90_WORK_FILES_ARG
677 < MODDIRFLAG
678 < F90MODINCSPEC
679 < F90_MODULE_NAMES
680 < ZLIB_INC_DIR
681 < ZLIB_LIB_DIR
682 < ZLIB
683 < FFTW_INC_DIR
684 < FFTW_LIB_DIR
685 < FFTW_LIBS
686 < QHULL_INC_DIR
687 < QHULL_LIB_DIR
688 < QHULL
689 < USE_QHULL
690 < CXXCPP
691 < OPENBABEL_INC_DIR
692 < OPENBABEL_LIB_DIR
693 < OPENBABEL_LIB
694 < USE_OPENBABEL
695 < LIBOBJS
696 < POW_LIB
697 < CGAL_MAKEFILE
698 < CGAL_CXXFLAGS
699 < CGAL_CPPFLAGS
700 < CGAL_LDFLAGS
701 < CGAL_LIBS
702 < USE_CGAL
703 < DOXYGEN
704 < DOT
705 < DOC
706 < enable_dot
707 < enable_html_docs
708 < enable_latex_docs
709 < BATEXT
710 < MKINSTALLDIRS
773 < OOPSE
774 < OOPSE_HOME
775 < SUBDIRS
776 < LTLIBOBJS'
653 > CFLAGS
654 > CC
655 > OBJEXT
656 > EXEEXT
657 > ac_ct_CXX
658 > CPPFLAGS
659 > LDFLAGS
660 > CXXFLAGS
661 > CXX
662 > USE_SINGLE_PRECISION
663 > debug
664 > PROGNAME
665 > host_os
666 > host_vendor
667 > host_cpu
668 > host
669 > build_os
670 > build_vendor
671 > build_cpu
672 > build
673 > target_alias
674 > host_alias
675 > build_alias
676 > LIBS
677 > ECHO_T
678 > ECHO_N
679 > ECHO_C
680 > DEFS
681 > mandir
682 > localedir
683 > libdir
684 > psdir
685 > pdfdir
686 > dvidir
687 > htmldir
688 > infodir
689 > docdir
690 > oldincludedir
691 > includedir
692 > localstatedir
693 > sharedstatedir
694 > sysconfdir
695 > datadir
696 > datarootdir
697 > libexecdir
698 > sbindir
699 > bindir
700 > program_transform_name
701 > prefix
702 > exec_prefix
703 > PACKAGE_URL
704 > PACKAGE_BUGREPORT
705 > PACKAGE_STRING
706 > PACKAGE_VERSION
707 > PACKAGE_TARNAME
708 > PACKAGE_NAME
709 > PATH_SEPARATOR
710 > SHELL'
711   ac_subst_files=''
712   ac_user_opts='
713   enable_option_checking
714 < enable_oopse_home
714 > enable_openmd_home
715   enable_debug
716   enable_single
717   enable_float
784 – with_mpi
718   with_perl_shebang
719   with_zlib
720   with_fftw
721   with_qhull
722   with_openbabel
790 – with_cgalmakefile
723   enable_doxygen
724   enable_dot
725   enable_html_docs
# Line 804 | Line 736 | CFLAGS
736   CCC
737   CC
738   CFLAGS
739 < FC
740 < FCFLAGS
739 > MPICXX
740 > MPICC
741   CPP
742   CXXCPP'
743  
# Line 870 | Line 802 | do
802    fi
803  
804    case $ac_option in
805 <  *=*)  ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
806 <  *)    ac_optarg=yes ;;
805 >  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
806 >  *=)   ac_optarg= ;;
807 >  *)    ac_optarg=yes ;;
808    esac
809  
810    # Accept the important Cygnus configure options, so we can diagnose typos.
# Line 916 | Line 849 | do
849      ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
850      # Reject names that are not valid shell variable names.
851      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
852 <      { $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
920 <   { (exit 1); exit 1; }; }
852 >      as_fn_error $? "invalid feature name: $ac_useropt"
853      ac_useropt_orig=$ac_useropt
854      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
855      case $ac_user_opts in
# Line 943 | Line 875 | do
875      ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
876      # Reject names that are not valid shell variable names.
877      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
878 <      { $as_echo "$as_me: error: invalid feature name: $ac_useropt" >&2
947 <   { (exit 1); exit 1; }; }
878 >      as_fn_error $? "invalid feature name: $ac_useropt"
879      ac_useropt_orig=$ac_useropt
880      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
881      case $ac_user_opts in
# Line 1148 | Line 1079 | do
1079      ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1080      # Reject names that are not valid shell variable names.
1081      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1082 <      { $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1152 <   { (exit 1); exit 1; }; }
1082 >      as_fn_error $? "invalid package name: $ac_useropt"
1083      ac_useropt_orig=$ac_useropt
1084      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1085      case $ac_user_opts in
# Line 1165 | Line 1095 | do
1095      ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1096      # Reject names that are not valid shell variable names.
1097      expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1098 <      { $as_echo "$as_me: error: invalid package name: $ac_useropt" >&2
1169 <   { (exit 1); exit 1; }; }
1098 >      as_fn_error $? "invalid package name: $ac_useropt"
1099      ac_useropt_orig=$ac_useropt
1100      ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1101      case $ac_user_opts in
# Line 1196 | Line 1125 | do
1125    | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1126      x_libraries=$ac_optarg ;;
1127  
1128 <  -*) { $as_echo "$as_me: error: unrecognized option: $ac_option
1129 < Try \`$0 --help' for more information." >&2
1201 <   { (exit 1); exit 1; }; }
1128 >  -*) as_fn_error $? "unrecognized option: \`$ac_option'
1129 > Try \`$0 --help' for more information"
1130      ;;
1131  
1132    *=*)
1133      ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1134      # Reject names that are not valid shell variable names.
1135 <    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
1136 <      { $as_echo "$as_me: error: invalid variable name: $ac_envvar" >&2
1137 <   { (exit 1); exit 1; }; }
1135 >    case $ac_envvar in #(
1136 >      '' | [0-9]* | *[!_$as_cr_alnum]* )
1137 >      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1138 >    esac
1139      eval $ac_envvar=\$ac_optarg
1140      export $ac_envvar ;;
1141  
# Line 1215 | Line 1144 | Try \`$0 --help' for more information." >&2
1144      $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1145      expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1146        $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1147 <    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
1147 >    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1148      ;;
1149  
1150    esac
# Line 1223 | Line 1152 | if test -n "$ac_prev"; then
1152  
1153   if test -n "$ac_prev"; then
1154    ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1155 <  { $as_echo "$as_me: error: missing argument to $ac_option" >&2
1227 <   { (exit 1); exit 1; }; }
1155 >  as_fn_error $? "missing argument to $ac_option"
1156   fi
1157  
1158   if test -n "$ac_unrecognized_opts"; then
1159    case $enable_option_checking in
1160      no) ;;
1161 <    fatal) { $as_echo "$as_me: error: Unrecognized options: $ac_unrecognized_opts" >&2
1162 <   { (exit 1); exit 1; }; } ;;
1235 <    *)     $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2 ;;
1161 >    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1162 >    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1163    esac
1164   fi
1165  
# Line 1254 | Line 1181 | do
1181      [\\/$]* | ?:[\\/]* )  continue;;
1182      NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1183    esac
1184 <  { $as_echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
1258 <   { (exit 1); exit 1; }; }
1184 >  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1185   done
1186  
1187   # There might be people who depend on the old broken behavior: `$host'
# Line 1269 | Line 1195 | if test "x$host_alias" != x; then
1195   if test "x$host_alias" != x; then
1196    if test "x$build_alias" = x; then
1197      cross_compiling=maybe
1198 <    $as_echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
1199 <    If a cross compiler is detected then cross compile mode will be used." >&2
1198 >    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
1199 >    If a cross compiler is detected then cross compile mode will be used" >&2
1200    elif test "x$build_alias" != "x$host_alias"; then
1201      cross_compiling=yes
1202    fi
# Line 1285 | Line 1211 | ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1211   ac_pwd=`pwd` && test -n "$ac_pwd" &&
1212   ac_ls_di=`ls -di .` &&
1213   ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1214 <  { $as_echo "$as_me: error: Working directory cannot be determined" >&2
1289 <   { (exit 1); exit 1; }; }
1214 >  as_fn_error $? "working directory cannot be determined"
1215   test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1216 <  { $as_echo "$as_me: error: pwd does not report name of working directory" >&2
1292 <   { (exit 1); exit 1; }; }
1216 >  as_fn_error $? "pwd does not report name of working directory"
1217  
1218  
1219   # Find the source files, if location was not specified.
# Line 1328 | Line 1252 | if test ! -r "$srcdir/$ac_unique_file"; then
1252   fi
1253   if test ! -r "$srcdir/$ac_unique_file"; then
1254    test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1255 <  { $as_echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
1332 <   { (exit 1); exit 1; }; }
1255 >  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1256   fi
1257   ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1258   ac_abs_confdir=`(
1259 <        cd "$srcdir" && test -r "./$ac_unique_file" || { $as_echo "$as_me: error: $ac_msg" >&2
1337 <   { (exit 1); exit 1; }; }
1259 >        cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1260          pwd)`
1261   # When building in place, set srcdir=.
1262   if test "$ac_abs_confdir" = "$ac_pwd"; then
# Line 1360 | Line 1282 | if test "$ac_init_help" = "long"; then
1282    # Omit some internal or obsolete options to make the list less imposing.
1283    # This message is too long to be a string in the A/UX 3.1 sh.
1284    cat <<_ACEOF
1285 < \`configure' configures OOPSE 4.0 to adapt to many kinds of systems.
1285 > \`configure' configures OpenMD 2.0 to adapt to many kinds of systems.
1286  
1287   Usage: $0 [OPTION]... [VAR=VALUE]...
1288  
# Line 1374 | Line 1296 | Configuration:
1296        --help=short        display options specific to this package
1297        --help=recursive    display the short help of all the included packages
1298    -V, --version           display version information and exit
1299 <  -q, --quiet, --silent   do not print \`checking...' messages
1299 >  -q, --quiet, --silent   do not print \`checking ...' messages
1300        --cache-file=FILE   cache test results in FILE [disabled]
1301    -C, --config-cache      alias for \`--cache-file=config.cache'
1302    -n, --no-create         do not create output files
# Line 1408 | Line 1330 | Fine tuning of the installation directories:
1330    --infodir=DIR           info documentation [DATAROOTDIR/info]
1331    --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1332    --mandir=DIR            man documentation [DATAROOTDIR/man]
1333 <  --docdir=DIR            documentation root [DATAROOTDIR/doc/oopse]
1333 >  --docdir=DIR            documentation root [DATAROOTDIR/doc/openmd]
1334    --htmldir=DIR           html documentation [DOCDIR]
1335    --dvidir=DIR            dvi documentation [DOCDIR]
1336    --pdfdir=DIR            pdf documentation [DOCDIR]
# Line 1425 | Line 1347 | if test -n "$ac_init_help"; then
1347  
1348   if test -n "$ac_init_help"; then
1349    case $ac_init_help in
1350 <     short | recursive ) echo "Configuration of OOPSE 4.0:";;
1350 >     short | recursive ) echo "Configuration of OpenMD 2.0:";;
1351     esac
1352    cat <<\_ACEOF
1353  
# Line 1433 | Line 1355 | Optional Features:
1355    --disable-option-checking  ignore unrecognized --enable/--with options
1356    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1357    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1358 <  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
1359 <  --enable-debug          Compile OOPSE in debug mode
1360 <  --enable-single         compile OOPSE in single precision
1358 >  --enable-openmd-home=DIR      define OpenMD home dir PREFIX/openmd
1359 >  --enable-debug          Compile OpenMD in debug mode
1360 >  --enable-single         compile OpenMD in single precision
1361    --enable-float          synonym for --enable-single
1362    --enable-doxygen        enable documentation generation with doxygen (auto)
1363    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
# Line 1445 | Line 1367 | Optional Packages:
1367   Optional Packages:
1368    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1369    --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]
1370    --with-perl-shebang     override what perl thinks is the way for the kernel
1371                            to start it (seldom needed)
1372    --with-zlib=DIR         root directory path of zlib installation (defaults
# Line 1459 | Line 1378 | Optional Packages:
1378    --with-openbabel=DIR    root directory path of openbabel-2.x installation
1379                            (defaults to /usr/local or /usr if not found in
1380                            /usr/local)
1462 –  --with-cgalmakefile=makefile
1463 –                          Use the following CGAL makefile
1381  
1382   Some influential environment variables:
1383    CXX         C++ compiler command
# Line 1468 | Line 1385 | Some influential environment variables:
1385    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1386                nonstandard directory <lib dir>
1387    LIBS        libraries to pass to the linker, e.g. -l<library>
1388 <  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1388 >  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1389                you have headers in a nonstandard directory <include dir>
1390    CC          C compiler command
1391    CFLAGS      C compiler flags
1392 <  FC          Fortran compiler command
1393 <  FCFLAGS     Fortran compiler flags
1392 >  MPICXX      MPI C++ compiler command
1393 >  MPICC       MPI C compiler command
1394    CPP         C preprocessor
1395    CXXCPP      C++ preprocessor
1396  
# Line 1543 | Line 1460 | if $ac_init_version; then
1460   test -n "$ac_init_help" && exit $ac_status
1461   if $ac_init_version; then
1462    cat <<\_ACEOF
1463 < OOPSE configure 4.0
1464 < generated by GNU Autoconf 2.62
1463 > OpenMD configure 2.0
1464 > generated by GNU Autoconf 2.68
1465  
1466 < Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1550 < 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
1466 > Copyright (C) 2010 Free Software Foundation, Inc.
1467   This configure script is free software; the Free Software Foundation
1468   gives unlimited permission to copy, distribute and modify it.
1469   _ACEOF
1470    exit
1471   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.
1472  
1473 < It was created by OOPSE $as_me 4.0, which was
1474 < generated by GNU Autoconf 2.62.  Invocation command line was
1473 > ## ------------------------ ##
1474 > ## Autoconf initialization. ##
1475 > ## ------------------------ ##
1476  
1477 <  $ $0 $@
1478 <
1479 < _ACEOF
1480 < exec 5>>config.log
1477 > # ac_fn_cxx_try_compile LINENO
1478 > # ----------------------------
1479 > # Try to compile conftest.$ac_ext, and return whether this succeeded.
1480 > ac_fn_cxx_try_compile ()
1481   {
1482 < cat <<_ASUNAME
1483 < ## --------- ##
1484 < ## Platform. ##
1485 < ## --------- ##
1482 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1483 >  rm -f conftest.$ac_objext
1484 >  if { { ac_try="$ac_compile"
1485 > case "(($ac_try" in
1486 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1487 >  *) ac_try_echo=$ac_try;;
1488 > esac
1489 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1490 > $as_echo "$ac_try_echo"; } >&5
1491 >  (eval "$ac_compile") 2>conftest.err
1492 >  ac_status=$?
1493 >  if test -s conftest.err; then
1494 >    grep -v '^ *+' conftest.err >conftest.er1
1495 >    cat conftest.er1 >&5
1496 >    mv -f conftest.er1 conftest.err
1497 >  fi
1498 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1499 >  test $ac_status = 0; } && {
1500 >         test -z "$ac_cxx_werror_flag" ||
1501 >         test ! -s conftest.err
1502 >       } && test -s conftest.$ac_objext; then :
1503 >  ac_retval=0
1504 > else
1505 >  $as_echo "$as_me: failed program was:" >&5
1506 > sed 's/^/| /' conftest.$ac_ext >&5
1507  
1508 < hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1509 < uname -m = `(uname -m) 2>/dev/null || echo unknown`
1510 < uname -r = `(uname -r) 2>/dev/null || echo unknown`
1511 < uname -s = `(uname -s) 2>/dev/null || echo unknown`
1577 < uname -v = `(uname -v) 2>/dev/null || echo unknown`
1508 >        ac_retval=1
1509 > fi
1510 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1511 >  as_fn_set_status $ac_retval
1512  
1513 < /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1513 > } # ac_fn_cxx_try_compile
1514 >
1515 > # ac_fn_c_try_compile LINENO
1516 > # --------------------------
1517 > # Try to compile conftest.$ac_ext, and return whether this succeeded.
1518 > ac_fn_c_try_compile ()
1519 > {
1520 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1521 >  rm -f conftest.$ac_objext
1522 >  if { { ac_try="$ac_compile"
1523 > case "(($ac_try" in
1524 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1525 >  *) ac_try_echo=$ac_try;;
1526 > esac
1527 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1528 > $as_echo "$ac_try_echo"; } >&5
1529 >  (eval "$ac_compile") 2>conftest.err
1530 >  ac_status=$?
1531 >  if test -s conftest.err; then
1532 >    grep -v '^ *+' conftest.err >conftest.er1
1533 >    cat conftest.er1 >&5
1534 >    mv -f conftest.er1 conftest.err
1535 >  fi
1536 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1537 >  test $ac_status = 0; } && {
1538 >         test -z "$ac_c_werror_flag" ||
1539 >         test ! -s conftest.err
1540 >       } && test -s conftest.$ac_objext; then :
1541 >  ac_retval=0
1542 > else
1543 >  $as_echo "$as_me: failed program was:" >&5
1544 > sed 's/^/| /' conftest.$ac_ext >&5
1545 >
1546 >        ac_retval=1
1547 > fi
1548 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1549 >  as_fn_set_status $ac_retval
1550 >
1551 > } # ac_fn_c_try_compile
1552 >
1553 > # ac_fn_cxx_try_link LINENO
1554 > # -------------------------
1555 > # Try to link conftest.$ac_ext, and return whether this succeeded.
1556 > ac_fn_cxx_try_link ()
1557 > {
1558 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1559 >  rm -f conftest.$ac_objext conftest$ac_exeext
1560 >  if { { ac_try="$ac_link"
1561 > case "(($ac_try" in
1562 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1563 >  *) ac_try_echo=$ac_try;;
1564 > esac
1565 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1566 > $as_echo "$ac_try_echo"; } >&5
1567 >  (eval "$ac_link") 2>conftest.err
1568 >  ac_status=$?
1569 >  if test -s conftest.err; then
1570 >    grep -v '^ *+' conftest.err >conftest.er1
1571 >    cat conftest.er1 >&5
1572 >    mv -f conftest.er1 conftest.err
1573 >  fi
1574 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1575 >  test $ac_status = 0; } && {
1576 >         test -z "$ac_cxx_werror_flag" ||
1577 >         test ! -s conftest.err
1578 >       } && test -s conftest$ac_exeext && {
1579 >         test "$cross_compiling" = yes ||
1580 >         $as_test_x conftest$ac_exeext
1581 >       }; then :
1582 >  ac_retval=0
1583 > else
1584 >  $as_echo "$as_me: failed program was:" >&5
1585 > sed 's/^/| /' conftest.$ac_ext >&5
1586 >
1587 >        ac_retval=1
1588 > fi
1589 >  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1590 >  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1591 >  # interfere with the next link command; also delete a directory that is
1592 >  # left behind by Apple's compiler.  We do this before executing the actions.
1593 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1594 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1595 >  as_fn_set_status $ac_retval
1596 >
1597 > } # ac_fn_cxx_try_link
1598 >
1599 > # ac_fn_cxx_check_func LINENO FUNC VAR
1600 > # ------------------------------------
1601 > # Tests whether FUNC exists, setting the cache variable VAR accordingly
1602 > ac_fn_cxx_check_func ()
1603 > {
1604 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1605 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1606 > $as_echo_n "checking for $2... " >&6; }
1607 > if eval \${$3+:} false; then :
1608 >  $as_echo_n "(cached) " >&6
1609 > else
1610 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1611 > /* end confdefs.h.  */
1612 > /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1613 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1614 > #define $2 innocuous_$2
1615 >
1616 > /* System header to define __stub macros and hopefully few prototypes,
1617 >    which can conflict with char $2 (); below.
1618 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1619 >    <limits.h> exists even on freestanding compilers.  */
1620 >
1621 > #ifdef __STDC__
1622 > # include <limits.h>
1623 > #else
1624 > # include <assert.h>
1625 > #endif
1626 >
1627 > #undef $2
1628 >
1629 > /* Override any GCC internal prototype to avoid an error.
1630 >   Use char because int might match the return type of a GCC
1631 >   builtin and then its argument prototype would still apply.  */
1632 > #ifdef __cplusplus
1633 > extern "C"
1634 > #endif
1635 > char $2 ();
1636 > /* The GNU C library defines this for functions which it implements
1637 >    to always fail with ENOSYS.  Some functions are actually named
1638 >    something starting with __ and the normal name is an alias.  */
1639 > #if defined __stub_$2 || defined __stub___$2
1640 > choke me
1641 > #endif
1642 >
1643 > int
1644 > main ()
1645 > {
1646 > return $2 ();
1647 >  ;
1648 >  return 0;
1649 > }
1650 > _ACEOF
1651 > if ac_fn_cxx_try_link "$LINENO"; then :
1652 >  eval "$3=yes"
1653 > else
1654 >  eval "$3=no"
1655 > fi
1656 > rm -f core conftest.err conftest.$ac_objext \
1657 >    conftest$ac_exeext conftest.$ac_ext
1658 > fi
1659 > eval ac_res=\$$3
1660 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1661 > $as_echo "$ac_res" >&6; }
1662 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1663 >
1664 > } # ac_fn_cxx_check_func
1665 >
1666 > # ac_fn_c_try_link LINENO
1667 > # -----------------------
1668 > # Try to link conftest.$ac_ext, and return whether this succeeded.
1669 > ac_fn_c_try_link ()
1670 > {
1671 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1672 >  rm -f conftest.$ac_objext conftest$ac_exeext
1673 >  if { { ac_try="$ac_link"
1674 > case "(($ac_try" in
1675 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1676 >  *) ac_try_echo=$ac_try;;
1677 > esac
1678 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1679 > $as_echo "$ac_try_echo"; } >&5
1680 >  (eval "$ac_link") 2>conftest.err
1681 >  ac_status=$?
1682 >  if test -s conftest.err; then
1683 >    grep -v '^ *+' conftest.err >conftest.er1
1684 >    cat conftest.er1 >&5
1685 >    mv -f conftest.er1 conftest.err
1686 >  fi
1687 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1688 >  test $ac_status = 0; } && {
1689 >         test -z "$ac_c_werror_flag" ||
1690 >         test ! -s conftest.err
1691 >       } && test -s conftest$ac_exeext && {
1692 >         test "$cross_compiling" = yes ||
1693 >         $as_test_x conftest$ac_exeext
1694 >       }; then :
1695 >  ac_retval=0
1696 > else
1697 >  $as_echo "$as_me: failed program was:" >&5
1698 > sed 's/^/| /' conftest.$ac_ext >&5
1699 >
1700 >        ac_retval=1
1701 > fi
1702 >  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1703 >  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1704 >  # interfere with the next link command; also delete a directory that is
1705 >  # left behind by Apple's compiler.  We do this before executing the actions.
1706 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1707 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1708 >  as_fn_set_status $ac_retval
1709 >
1710 > } # ac_fn_c_try_link
1711 >
1712 > # ac_fn_c_check_func LINENO FUNC VAR
1713 > # ----------------------------------
1714 > # Tests whether FUNC exists, setting the cache variable VAR accordingly
1715 > ac_fn_c_check_func ()
1716 > {
1717 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1718 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1719 > $as_echo_n "checking for $2... " >&6; }
1720 > if eval \${$3+:} false; then :
1721 >  $as_echo_n "(cached) " >&6
1722 > else
1723 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1724 > /* end confdefs.h.  */
1725 > /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1726 >   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1727 > #define $2 innocuous_$2
1728 >
1729 > /* System header to define __stub macros and hopefully few prototypes,
1730 >    which can conflict with char $2 (); below.
1731 >    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1732 >    <limits.h> exists even on freestanding compilers.  */
1733 >
1734 > #ifdef __STDC__
1735 > # include <limits.h>
1736 > #else
1737 > # include <assert.h>
1738 > #endif
1739 >
1740 > #undef $2
1741 >
1742 > /* Override any GCC internal prototype to avoid an error.
1743 >   Use char because int might match the return type of a GCC
1744 >   builtin and then its argument prototype would still apply.  */
1745 > #ifdef __cplusplus
1746 > extern "C"
1747 > #endif
1748 > char $2 ();
1749 > /* The GNU C library defines this for functions which it implements
1750 >    to always fail with ENOSYS.  Some functions are actually named
1751 >    something starting with __ and the normal name is an alias.  */
1752 > #if defined __stub_$2 || defined __stub___$2
1753 > choke me
1754 > #endif
1755 >
1756 > int
1757 > main ()
1758 > {
1759 > return $2 ();
1760 >  ;
1761 >  return 0;
1762 > }
1763 > _ACEOF
1764 > if ac_fn_c_try_link "$LINENO"; then :
1765 >  eval "$3=yes"
1766 > else
1767 >  eval "$3=no"
1768 > fi
1769 > rm -f core conftest.err conftest.$ac_objext \
1770 >    conftest$ac_exeext conftest.$ac_ext
1771 > fi
1772 > eval ac_res=\$$3
1773 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1774 > $as_echo "$ac_res" >&6; }
1775 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1776 >
1777 > } # ac_fn_c_check_func
1778 >
1779 > # ac_fn_c_try_cpp LINENO
1780 > # ----------------------
1781 > # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1782 > ac_fn_c_try_cpp ()
1783 > {
1784 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1785 >  if { { ac_try="$ac_cpp conftest.$ac_ext"
1786 > case "(($ac_try" in
1787 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1788 >  *) ac_try_echo=$ac_try;;
1789 > esac
1790 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1791 > $as_echo "$ac_try_echo"; } >&5
1792 >  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1793 >  ac_status=$?
1794 >  if test -s conftest.err; then
1795 >    grep -v '^ *+' conftest.err >conftest.er1
1796 >    cat conftest.er1 >&5
1797 >    mv -f conftest.er1 conftest.err
1798 >  fi
1799 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1800 >  test $ac_status = 0; } > conftest.i && {
1801 >         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
1802 >         test ! -s conftest.err
1803 >       }; then :
1804 >  ac_retval=0
1805 > else
1806 >  $as_echo "$as_me: failed program was:" >&5
1807 > sed 's/^/| /' conftest.$ac_ext >&5
1808 >
1809 >    ac_retval=1
1810 > fi
1811 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1812 >  as_fn_set_status $ac_retval
1813 >
1814 > } # ac_fn_c_try_cpp
1815 >
1816 > # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1817 > # -------------------------------------------------------
1818 > # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1819 > # the include files in INCLUDES and setting the cache variable VAR
1820 > # accordingly.
1821 > ac_fn_c_check_header_mongrel ()
1822 > {
1823 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1824 >  if eval \${$3+:} false; then :
1825 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1826 > $as_echo_n "checking for $2... " >&6; }
1827 > if eval \${$3+:} false; then :
1828 >  $as_echo_n "(cached) " >&6
1829 > fi
1830 > eval ac_res=\$$3
1831 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1832 > $as_echo "$ac_res" >&6; }
1833 > else
1834 >  # Is the header compilable?
1835 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1836 > $as_echo_n "checking $2 usability... " >&6; }
1837 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1838 > /* end confdefs.h.  */
1839 > $4
1840 > #include <$2>
1841 > _ACEOF
1842 > if ac_fn_c_try_compile "$LINENO"; then :
1843 >  ac_header_compiler=yes
1844 > else
1845 >  ac_header_compiler=no
1846 > fi
1847 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1848 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1849 > $as_echo "$ac_header_compiler" >&6; }
1850 >
1851 > # Is the header present?
1852 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1853 > $as_echo_n "checking $2 presence... " >&6; }
1854 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1855 > /* end confdefs.h.  */
1856 > #include <$2>
1857 > _ACEOF
1858 > if ac_fn_c_try_cpp "$LINENO"; then :
1859 >  ac_header_preproc=yes
1860 > else
1861 >  ac_header_preproc=no
1862 > fi
1863 > rm -f conftest.err conftest.i conftest.$ac_ext
1864 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1865 > $as_echo "$ac_header_preproc" >&6; }
1866 >
1867 > # So?  What about this header?
1868 > case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1869 >  yes:no: )
1870 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1871 > $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1872 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1873 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1874 >    ;;
1875 >  no:yes:* )
1876 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1877 > $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1878 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1879 > $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1880 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1881 > $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1882 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1883 > $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1884 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1885 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1886 > ( $as_echo "## ------------------------------ ##
1887 > ## Report this to gezelter@nd.edu ##
1888 > ## ------------------------------ ##"
1889 >     ) | sed "s/^/$as_me: WARNING:     /" >&2
1890 >    ;;
1891 > esac
1892 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1893 > $as_echo_n "checking for $2... " >&6; }
1894 > if eval \${$3+:} false; then :
1895 >  $as_echo_n "(cached) " >&6
1896 > else
1897 >  eval "$3=\$ac_header_compiler"
1898 > fi
1899 > eval ac_res=\$$3
1900 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1901 > $as_echo "$ac_res" >&6; }
1902 > fi
1903 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1904 >
1905 > } # ac_fn_c_check_header_mongrel
1906 >
1907 > # ac_fn_c_try_run LINENO
1908 > # ----------------------
1909 > # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
1910 > # that executables *can* be run.
1911 > ac_fn_c_try_run ()
1912 > {
1913 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1914 >  if { { ac_try="$ac_link"
1915 > case "(($ac_try" in
1916 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1917 >  *) ac_try_echo=$ac_try;;
1918 > esac
1919 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1920 > $as_echo "$ac_try_echo"; } >&5
1921 >  (eval "$ac_link") 2>&5
1922 >  ac_status=$?
1923 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1924 >  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
1925 >  { { case "(($ac_try" in
1926 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1927 >  *) ac_try_echo=$ac_try;;
1928 > esac
1929 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1930 > $as_echo "$ac_try_echo"; } >&5
1931 >  (eval "$ac_try") 2>&5
1932 >  ac_status=$?
1933 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1934 >  test $ac_status = 0; }; }; then :
1935 >  ac_retval=0
1936 > else
1937 >  $as_echo "$as_me: program exited with status $ac_status" >&5
1938 >       $as_echo "$as_me: failed program was:" >&5
1939 > sed 's/^/| /' conftest.$ac_ext >&5
1940 >
1941 >       ac_retval=$ac_status
1942 > fi
1943 >  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1944 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1945 >  as_fn_set_status $ac_retval
1946 >
1947 > } # ac_fn_c_try_run
1948 >
1949 > # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
1950 > # -------------------------------------------------------
1951 > # Tests whether HEADER exists and can be compiled using the include files in
1952 > # INCLUDES, setting the cache variable VAR accordingly.
1953 > ac_fn_c_check_header_compile ()
1954 > {
1955 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1956 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1957 > $as_echo_n "checking for $2... " >&6; }
1958 > if eval \${$3+:} false; then :
1959 >  $as_echo_n "(cached) " >&6
1960 > else
1961 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1962 > /* end confdefs.h.  */
1963 > $4
1964 > #include <$2>
1965 > _ACEOF
1966 > if ac_fn_c_try_compile "$LINENO"; then :
1967 >  eval "$3=yes"
1968 > else
1969 >  eval "$3=no"
1970 > fi
1971 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1972 > fi
1973 > eval ac_res=\$$3
1974 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1975 > $as_echo "$ac_res" >&6; }
1976 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1977 >
1978 > } # ac_fn_c_check_header_compile
1979 >
1980 > # ac_fn_cxx_try_cpp LINENO
1981 > # ------------------------
1982 > # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1983 > ac_fn_cxx_try_cpp ()
1984 > {
1985 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1986 >  if { { ac_try="$ac_cpp conftest.$ac_ext"
1987 > case "(($ac_try" in
1988 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1989 >  *) ac_try_echo=$ac_try;;
1990 > esac
1991 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1992 > $as_echo "$ac_try_echo"; } >&5
1993 >  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1994 >  ac_status=$?
1995 >  if test -s conftest.err; then
1996 >    grep -v '^ *+' conftest.err >conftest.er1
1997 >    cat conftest.er1 >&5
1998 >    mv -f conftest.er1 conftest.err
1999 >  fi
2000 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2001 >  test $ac_status = 0; } > conftest.i && {
2002 >         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2003 >         test ! -s conftest.err
2004 >       }; then :
2005 >  ac_retval=0
2006 > else
2007 >  $as_echo "$as_me: failed program was:" >&5
2008 > sed 's/^/| /' conftest.$ac_ext >&5
2009 >
2010 >    ac_retval=1
2011 > fi
2012 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2013 >  as_fn_set_status $ac_retval
2014 >
2015 > } # ac_fn_cxx_try_cpp
2016 >
2017 > # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2018 > # ---------------------------------------------------------
2019 > # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2020 > # the include files in INCLUDES and setting the cache variable VAR
2021 > # accordingly.
2022 > ac_fn_cxx_check_header_mongrel ()
2023 > {
2024 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2025 >  if eval \${$3+:} false; then :
2026 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2027 > $as_echo_n "checking for $2... " >&6; }
2028 > if eval \${$3+:} false; then :
2029 >  $as_echo_n "(cached) " >&6
2030 > fi
2031 > eval ac_res=\$$3
2032 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2033 > $as_echo "$ac_res" >&6; }
2034 > else
2035 >  # Is the header compilable?
2036 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2037 > $as_echo_n "checking $2 usability... " >&6; }
2038 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2039 > /* end confdefs.h.  */
2040 > $4
2041 > #include <$2>
2042 > _ACEOF
2043 > if ac_fn_cxx_try_compile "$LINENO"; then :
2044 >  ac_header_compiler=yes
2045 > else
2046 >  ac_header_compiler=no
2047 > fi
2048 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2049 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2050 > $as_echo "$ac_header_compiler" >&6; }
2051 >
2052 > # Is the header present?
2053 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2054 > $as_echo_n "checking $2 presence... " >&6; }
2055 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2056 > /* end confdefs.h.  */
2057 > #include <$2>
2058 > _ACEOF
2059 > if ac_fn_cxx_try_cpp "$LINENO"; then :
2060 >  ac_header_preproc=yes
2061 > else
2062 >  ac_header_preproc=no
2063 > fi
2064 > rm -f conftest.err conftest.i conftest.$ac_ext
2065 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2066 > $as_echo "$ac_header_preproc" >&6; }
2067 >
2068 > # So?  What about this header?
2069 > case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2070 >  yes:no: )
2071 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2072 > $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2073 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2074 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2075 >    ;;
2076 >  no:yes:* )
2077 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2078 > $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2079 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2080 > $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2081 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2082 > $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2083 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2084 > $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2085 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2086 > $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2087 > ( $as_echo "## ------------------------------ ##
2088 > ## Report this to gezelter@nd.edu ##
2089 > ## ------------------------------ ##"
2090 >     ) | sed "s/^/$as_me: WARNING:     /" >&2
2091 >    ;;
2092 > esac
2093 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2094 > $as_echo_n "checking for $2... " >&6; }
2095 > if eval \${$3+:} false; then :
2096 >  $as_echo_n "(cached) " >&6
2097 > else
2098 >  eval "$3=\$ac_header_compiler"
2099 > fi
2100 > eval ac_res=\$$3
2101 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2102 > $as_echo "$ac_res" >&6; }
2103 > fi
2104 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2105 >
2106 > } # ac_fn_cxx_check_header_mongrel
2107 >
2108 > # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
2109 > # -------------------------------------------
2110 > # Tests whether TYPE exists after having included INCLUDES, setting cache
2111 > # variable VAR accordingly.
2112 > ac_fn_c_check_type ()
2113 > {
2114 >  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2115 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2116 > $as_echo_n "checking for $2... " >&6; }
2117 > if eval \${$3+:} false; then :
2118 >  $as_echo_n "(cached) " >&6
2119 > else
2120 >  eval "$3=no"
2121 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2122 > /* end confdefs.h.  */
2123 > $4
2124 > int
2125 > main ()
2126 > {
2127 > if (sizeof ($2))
2128 >         return 0;
2129 >  ;
2130 >  return 0;
2131 > }
2132 > _ACEOF
2133 > if ac_fn_c_try_compile "$LINENO"; then :
2134 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2135 > /* end confdefs.h.  */
2136 > $4
2137 > int
2138 > main ()
2139 > {
2140 > if (sizeof (($2)))
2141 >            return 0;
2142 >  ;
2143 >  return 0;
2144 > }
2145 > _ACEOF
2146 > if ac_fn_c_try_compile "$LINENO"; then :
2147 >
2148 > else
2149 >  eval "$3=yes"
2150 > fi
2151 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2152 > fi
2153 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2154 > fi
2155 > eval ac_res=\$$3
2156 >               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2157 > $as_echo "$ac_res" >&6; }
2158 >  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2159 >
2160 > } # ac_fn_c_check_type
2161 > cat >config.log <<_ACEOF
2162 > This file contains any messages produced by compilers while
2163 > running configure, to aid debugging if configure makes a mistake.
2164 >
2165 > It was created by OpenMD $as_me 2.0, which was
2166 > generated by GNU Autoconf 2.68.  Invocation command line was
2167 >
2168 >  $ $0 $@
2169 >
2170 > _ACEOF
2171 > exec 5>>config.log
2172 > {
2173 > cat <<_ASUNAME
2174 > ## --------- ##
2175 > ## Platform. ##
2176 > ## --------- ##
2177 >
2178 > hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
2179 > uname -m = `(uname -m) 2>/dev/null || echo unknown`
2180 > uname -r = `(uname -r) 2>/dev/null || echo unknown`
2181 > uname -s = `(uname -s) 2>/dev/null || echo unknown`
2182 > uname -v = `(uname -v) 2>/dev/null || echo unknown`
2183 >
2184 > /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
2185   /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
2186  
2187   /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
# Line 1594 | Line 2199 | do
2199   do
2200    IFS=$as_save_IFS
2201    test -z "$as_dir" && as_dir=.
2202 <  $as_echo "PATH: $as_dir"
2203 < done
2202 >    $as_echo "PATH: $as_dir"
2203 >  done
2204   IFS=$as_save_IFS
2205  
2206   } >&5
# Line 1632 | Line 2237 | do
2237        ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2238      esac
2239      case $ac_pass in
2240 <    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
2240 >    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2241      2)
2242 <      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
2242 >      as_fn_append ac_configure_args1 " '$ac_arg'"
2243        if test $ac_must_keep_next = true; then
2244          ac_must_keep_next=false # Got value, back to normal.
2245        else
# Line 1650 | Line 2255 | do
2255            -* ) ac_must_keep_next=true ;;
2256          esac
2257        fi
2258 <      ac_configure_args="$ac_configure_args '$ac_arg'"
2258 >      as_fn_append ac_configure_args " '$ac_arg'"
2259        ;;
2260      esac
2261    done
2262   done
2263 < $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
2264 < $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
2263 > { ac_configure_args0=; unset ac_configure_args0;}
2264 > { ac_configure_args1=; unset ac_configure_args1;}
2265  
2266   # When interrupted or exit'd, cleanup temporary files, and complete
2267   # config.log.  We remove comments because anyway the quotes in there
# Line 1668 | Line 2273 | trap 'exit_status=$?
2273    {
2274      echo
2275  
2276 <    cat <<\_ASBOX
1672 < ## ---------------- ##
2276 >    $as_echo "## ---------------- ##
2277   ## Cache variables. ##
2278 < ## ---------------- ##
1675 < _ASBOX
2278 > ## ---------------- ##"
2279      echo
2280      # The following way of writing the cache mishandles newlines in values,
2281   (
# Line 1681 | Line 2284 | _ASBOX
2284      case $ac_val in #(
2285      *${as_nl}*)
2286        case $ac_var in #(
2287 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
2288 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
2287 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2288 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2289        esac
2290        case $ac_var in #(
2291        _ | IFS | as_nl) ;; #(
2292        BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2293 <      *) $as_unset $ac_var ;;
2293 >      *) { eval $ac_var=; unset $ac_var;} ;;
2294        esac ;;
2295      esac
2296    done
# Line 1706 | Line 2309 | $as_echo "$as_me: WARNING: Cache variable $ac_var cont
2309   )
2310      echo
2311  
2312 <    cat <<\_ASBOX
1710 < ## ----------------- ##
2312 >    $as_echo "## ----------------- ##
2313   ## Output variables. ##
2314 < ## ----------------- ##
1713 < _ASBOX
2314 > ## ----------------- ##"
2315      echo
2316      for ac_var in $ac_subst_vars
2317      do
# Line 1723 | Line 2324 | _ASBOX
2324      echo
2325  
2326      if test -n "$ac_subst_files"; then
2327 <      cat <<\_ASBOX
1727 < ## ------------------- ##
2327 >      $as_echo "## ------------------- ##
2328   ## File substitutions. ##
2329 < ## ------------------- ##
1730 < _ASBOX
2329 > ## ------------------- ##"
2330        echo
2331        for ac_var in $ac_subst_files
2332        do
# Line 1741 | Line 2340 | _ASBOX
2340      fi
2341  
2342      if test -s confdefs.h; then
2343 <      cat <<\_ASBOX
1745 < ## ----------- ##
2343 >      $as_echo "## ----------- ##
2344   ## confdefs.h. ##
2345 < ## ----------- ##
1748 < _ASBOX
2345 > ## ----------- ##"
2346        echo
2347        cat confdefs.h
2348        echo
# Line 1759 | Line 2356 | for ac_signal in 1 2 13 15; do
2356      exit $exit_status
2357   ' 0
2358   for ac_signal in 1 2 13 15; do
2359 <  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
2359 >  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2360   done
2361   ac_signal=0
2362  
2363   # confdefs.h avoids OS command line length limits that DEFS can exceed.
2364   rm -f -r conftest* confdefs.h
2365  
2366 + $as_echo "/* confdefs.h */" > confdefs.h
2367 +
2368   # Predefined preprocessor variables.
2369  
2370   cat >>confdefs.h <<_ACEOF
2371   #define PACKAGE_NAME "$PACKAGE_NAME"
2372   _ACEOF
2373  
1775 –
2374   cat >>confdefs.h <<_ACEOF
2375   #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
2376   _ACEOF
2377  
1780 –
2378   cat >>confdefs.h <<_ACEOF
2379   #define PACKAGE_VERSION "$PACKAGE_VERSION"
2380   _ACEOF
2381  
1785 –
2382   cat >>confdefs.h <<_ACEOF
2383   #define PACKAGE_STRING "$PACKAGE_STRING"
2384   _ACEOF
2385  
1790 –
2386   cat >>confdefs.h <<_ACEOF
2387   #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
2388   _ACEOF
2389  
2390 + cat >>confdefs.h <<_ACEOF
2391 + #define PACKAGE_URL "$PACKAGE_URL"
2392 + _ACEOF
2393  
2394 +
2395   # Let the site file select an alternate cache file if it wants to.
2396   # Prefer an explicitly selected file to automatically selected ones.
2397   ac_site_file1=NONE
2398   ac_site_file2=NONE
2399   if test -n "$CONFIG_SITE"; then
2400 <  ac_site_file1=$CONFIG_SITE
2400 >  # We do not want a PATH search for config.site.
2401 >  case $CONFIG_SITE in #((
2402 >    -*)  ac_site_file1=./$CONFIG_SITE;;
2403 >    */*) ac_site_file1=$CONFIG_SITE;;
2404 >    *)   ac_site_file1=./$CONFIG_SITE;;
2405 >  esac
2406   elif test "x$prefix" != xNONE; then
2407    ac_site_file1=$prefix/share/config.site
2408    ac_site_file2=$prefix/etc/config.site
# Line 1809 | Line 2413 | do
2413   for ac_site_file in "$ac_site_file1" "$ac_site_file2"
2414   do
2415    test "x$ac_site_file" = xNONE && continue
2416 <  if test -r "$ac_site_file"; then
2417 <    { $as_echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
2416 >  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
2417 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2418   $as_echo "$as_me: loading site script $ac_site_file" >&6;}
2419      sed 's/^/| /' "$ac_site_file" >&5
2420 <    . "$ac_site_file"
2420 >    . "$ac_site_file" \
2421 >      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2422 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2423 > as_fn_error $? "failed to load site script $ac_site_file
2424 > See \`config.log' for more details" "$LINENO" 5; }
2425    fi
2426   done
2427  
2428   if test -r "$cache_file"; then
2429 <  # Some versions of bash will fail to source /dev/null (special
2430 <  # files actually), so we avoid doing that.
2431 <  if test -f "$cache_file"; then
2432 <    { $as_echo "$as_me:$LINENO: loading cache $cache_file" >&5
2429 >  # Some versions of bash will fail to source /dev/null (special files
2430 >  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
2431 >  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
2432 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2433   $as_echo "$as_me: loading cache $cache_file" >&6;}
2434      case $cache_file in
2435        [\\/]* | ?:[\\/]* ) . "$cache_file";;
# Line 1829 | Line 2437 | else
2437      esac
2438    fi
2439   else
2440 <  { $as_echo "$as_me:$LINENO: creating cache $cache_file" >&5
2440 >  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
2441   $as_echo "$as_me: creating cache $cache_file" >&6;}
2442    >$cache_file
2443   fi
# Line 1844 | Line 2452 | for ac_var in $ac_precious_vars; do
2452    eval ac_new_val=\$ac_env_${ac_var}_value
2453    case $ac_old_set,$ac_new_set in
2454      set,)
2455 <      { $as_echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2455 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2456   $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2457        ac_cache_corrupted=: ;;
2458      ,set)
2459 <      { $as_echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
2459 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
2460   $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2461        ac_cache_corrupted=: ;;
2462      ,);;
# Line 1858 | Line 2466 | $as_echo "$as_me: error: \`$ac_var' was not set in the
2466          ac_old_val_w=`echo x $ac_old_val`
2467          ac_new_val_w=`echo x $ac_new_val`
2468          if test "$ac_old_val_w" != "$ac_new_val_w"; then
2469 <          { $as_echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
2469 >          { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
2470   $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2471            ac_cache_corrupted=:
2472          else
2473 <          { $as_echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2473 >          { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2474   $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
2475            eval $ac_var=\$ac_old_val
2476          fi
2477 <        { $as_echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
2477 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
2478   $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
2479 <        { $as_echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
2479 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
2480   $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
2481        fi;;
2482    esac
# Line 1880 | Line 2488 | $as_echo "$as_me:   current value: \`$ac_new_val'" >&2
2488      esac
2489      case " $ac_configure_args " in
2490        *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
2491 <      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
2491 >      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
2492      esac
2493    fi
2494   done
2495   if $ac_cache_corrupted; then
2496 <  { $as_echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
2496 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2497 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2498 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
2499   $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2500 <  { { $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; }; }
2500 >  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
2501   fi
2502 <
2503 <
2504 <
1897 <
2502 > ## -------------------- ##
2503 > ## Main body of script. ##
2504 > ## -------------------- ##
2505  
1899 –
1900 –
1901 –
1902 –
1903 –
1904 –
1905 –
1906 –
1907 –
1908 –
1909 –
1910 –
1911 –
1912 –
1913 –
1914 –
1915 –
1916 –
1917 –
1918 –
2506   ac_ext=c
2507   ac_cpp='$CPP $CPPFLAGS'
2508   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 1940 | Line 2527 | if test -z "$ac_aux_dir"; then
2527    fi
2528   done
2529   if test -z "$ac_aux_dir"; then
2530 <  { { $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; }; }
2530 >  as_fn_error $? "cannot find install-sh, install.sh, or shtool in ac-tools \"$srcdir\"/ac-tools" "$LINENO" 5
2531   fi
2532  
2533   # These three variables are undocumented and unsupported,
# Line 1982 | Line 2567 | ac_config_headers="$ac_config_headers src/config.h"
2567  
2568  
2569  
1985 –
1986 –
1987 –
1988 –
1989 –
1990 –
1991 –
1992 –
1993 –
1994 –
1995 –
1996 –
1997 –
1998 –
1999 –
2000 –
2001 –
2002 –
2570   #
2571   #
2572   #
# Line 2013 | Line 2580 | ac_config_headers="$ac_config_headers src/config.h"
2580  
2581  
2582  
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
2583  
2584  
2585  
# Line 2106 | Line 2667 | ac_config_headers="$ac_config_headers src/config.h"
2667  
2668  
2669  
2670 < # ACX_MPI_GET_PROG
2671 <
2672 < # ACX_DETECT_MPI_IMPLEMENTATION
2673 <
2674 <
2675 <
2676 <
2677 <
2678 < # ACX_MPI
2679 <
2680 <
2681 <
2682 <
2683 <
2684 <
2685 <
2686 <
2687 <
2688 <
2689 <
2690 <
2691 <
2692 <
2693 <
2694 <
2695 <
2696 <
2697 <
2698 <
2699 <
2700 <
2701 <
2702 <
2703 <
2704 <
2705 <
2706 < # This is taken from http://autoqt.sourceforge.net/
2707 < # Copyright (c) 2002, Geoffrey Wossum
2708 < # All rights reserved.
2709 <
2710 < # Redistribution and use in source and binary forms, with or without
2711 < # modification, are permitted provided that the following conditions are
2712 < # met:
2713 <
2714 < #  - Redistributions of source code must retain the above copyright notice,
2715 < #    this list of conditions and the following disclaimer.
2716 <
2717 < #  - Redistributions in binary form must reproduce the above copyright
2718 < #    notice, this list of conditions and the following disclaimer in the
2719 < #    documentation and/or other materials provided with the distribution.
2670 > # ===========================================================================
2671 > #             http://www.nongnu.org/autoconf-archive/ax_mpi.html
2672 > # ===========================================================================
2673 > #
2674 > # SYNOPSIS
2675 > #
2676 > #   AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
2677 > #
2678 > # DESCRIPTION
2679 > #
2680 > #   This macro tries to find out how to compile programs that use MPI
2681 > #   (Message Passing Interface), a standard API for parallel process
2682 > #   communication (see http://www-unix.mcs.anl.gov/mpi/)
2683 > #
2684 > #   On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
2685 > #   to the name of the MPI compiler, depending upon the current language.
2686 > #   (This may just be $CC/$CXX/$F77/$FC, but is more often something like
2687 > #   mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
2688 > #   are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
2689 > #   MPICC/MPICXX/MPIF77/MPIFC was not found).
2690 > #
2691 > #   If you want to compile everything with MPI, you should set:
2692 > #
2693 > #       CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
2694 > #       LIBS="$MPILIBS $LIBS"
2695 > #
2696 > #   NOTE: The above assumes that you will use $CC (or whatever) for linking
2697 > #   as well as for compiling. (This is the default for automake and most
2698 > #   Makefiles.)
2699 > #
2700 > #   The user can force a particular library/compiler by setting the
2701 > #   MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
2702 > #
2703 > #   ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
2704 > #   found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
2705 > #   found. If ACTION-IF-FOUND is not specified, the default action will
2706 > #   define HAVE_MPI.
2707 > #
2708 > # LICENSE
2709 > #
2710 > #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2711 > #   Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
2712 > #
2713 > #   This program is free software: you can redistribute it and/or modify it
2714 > #   under the terms of the GNU General Public License as published by the
2715 > #   Free Software Foundation, either version 3 of the License, or (at your
2716 > #   option) any later version.
2717 > #
2718 > #   This program is distributed in the hope that it will be useful, but
2719 > #   WITHOUT ANY WARRANTY; without even the implied warranty of
2720 > #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2721 > #   Public License for more details.
2722 > #
2723 > #   You should have received a copy of the GNU General Public License along
2724 > #   with this program. If not, see <http://www.gnu.org/licenses/>.
2725 > #
2726 > #   As a special exception, the respective Autoconf Macro's copyright owner
2727 > #   gives unlimited permission to copy, distribute and modify the configure
2728 > #   scripts that are the output of Autoconf when processing the Macro. You
2729 > #   need not follow the terms of the GNU General Public License when using
2730 > #   or distributing such scripts, even though portions of the text of the
2731 > #   Macro appear in them. The GNU General Public License (GPL) does govern
2732 > #   all other use of the material that constitutes the Autoconf Macro.
2733 > #
2734 > #   This special exception to the GPL applies to versions of the Autoconf
2735 > #   Macro released by the Autoconf Archive. When you make and distribute a
2736 > #   modified version of the Autoconf Macro, you may extend this special
2737 > #   exception to the GPL to apply to your modified version as well.
2738  
2739 < #  - Neither the name of Geoffrey Wossum nor the names of its
2740 < #    contributors may be used to endorse or promote products derived from
2741 < #    this software without specific prior written permission.
2739 > # This is what autoupdate's m4 run will expand.  It fires
2740 > # the warning (with _au_warn_XXX), outputs it into the
2741 > # updated configure.ac (with AC_DIAGNOSE), and then outputs
2742 > # the replacement expansion.
2743  
2744  
2745 < # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2746 < # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
2747 < # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2748 < # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
2749 < # 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.
2745 > # This is an auxiliary macro that is also run when
2746 > # autoupdate runs m4.  It simply calls m4_warning, but
2747 > # we need a wrapper so that each warning is emitted only
2748 > # once.  We break the quoting in m4_warning's argument in
2749 > # order to expand this macro's arguments, not AU_DEFUN's.
2750  
2751  
2752 < # Check for Qt compiler flags, linker flags, and binary packages
2752 > # Finally, this is the expansion that is picked up by
2753 > # autoconf.  It tells the user to run autoupdate, and
2754 > # then outputs the replacement expansion.  We do not care
2755 > # about autoupdate's warning because that contains
2756 > # information on what to do *after* running autoupdate.
2757  
2758  
2759  
2760   # who am i
2761   # Make sure we can run config.sub.
2762   $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
2763 <  { { $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; }; }
2763 >  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2764  
2765 < { $as_echo "$as_me:$LINENO: checking build system type" >&5
2765 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2766   $as_echo_n "checking build system type... " >&6; }
2767 < if test "${ac_cv_build+set}" = set; then
2767 > if ${ac_cv_build+:} false; then :
2768    $as_echo_n "(cached) " >&6
2769   else
2770    ac_build_alias=$build_alias
2771   test "x$ac_build_alias" = x &&
2772    ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2773   test "x$ac_build_alias" = x &&
2774 <  { { $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; }; }
2774 >  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
2775   ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
2776 <  { { $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; }; }
2776 >  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2777  
2778   fi
2779 < { $as_echo "$as_me:$LINENO: result: $ac_cv_build" >&5
2779 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2780   $as_echo "$ac_cv_build" >&6; }
2781   case $ac_cv_build in
2782   *-*-*) ;;
2783 < *) { { $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; }; };;
2783 > *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
2784   esac
2785   build=$ac_cv_build
2786   ac_save_IFS=$IFS; IFS='-'
# Line 2226 | Line 2796 | case $build_os in *\ *) build_os=`echo "$build_os" | s
2796   case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
2797  
2798  
2799 < { $as_echo "$as_me:$LINENO: checking host system type" >&5
2799 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
2800   $as_echo_n "checking host system type... " >&6; }
2801 < if test "${ac_cv_host+set}" = set; then
2801 > if ${ac_cv_host+:} false; then :
2802    $as_echo_n "(cached) " >&6
2803   else
2804    if test "x$host_alias" = x; then
2805    ac_cv_host=$ac_cv_build
2806   else
2807    ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
2808 <    { { $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; }; }
2808 >    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
2809   fi
2810  
2811   fi
2812 < { $as_echo "$as_me:$LINENO: result: $ac_cv_host" >&5
2812 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
2813   $as_echo "$ac_cv_host" >&6; }
2814   case $ac_cv_host in
2815   *-*-*) ;;
2816 < *) { { $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; }; };;
2816 > *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
2817   esac
2818   host=$ac_cv_host
2819   ac_save_IFS=$IFS; IFS='-'
# Line 2267 | Line 2833 | case $host_os in *\ *) host_os=`echo "$host_os" | sed
2833  
2834  
2835   # set program name
2836 < PROGNAME="oopse"
2836 > PROGNAME="openmd"
2837  
2838  
2839  
2840  
2841   OBJEXT=".$OBJEXT"
2842  
2843 < OOPSE=oopse
2843 > OPENMD=openmd
2844  
2845   if test "x${prefix}" = "xNONE"
2846   then
2847 <  OOPSE_HOME=${ac_default_prefix}/oopse
2847 >  OPENMD_HOME=${ac_default_prefix}/openmd
2848   else
2849 <  OOPSE_HOME=${prefix}/oopse
2849 >  OPENMD_HOME=${prefix}/openmd
2850   fi
2851 < # Check whether --enable-oopse-home was given.
2852 < if test "${enable_oopse_home+set}" = set; then
2853 <  enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
2851 > # Check whether --enable-openmd-home was given.
2852 > if test "${enable_openmd_home+set}" = set; then :
2853 >  enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2854   fi
2855  
2856  
# Line 2293 | Line 2859 | debug=0
2859  
2860   debug=0
2861   # Check whether --enable-debug was given.
2862 < if test "${enable_debug+set}" = set; then
2862 > if test "${enable_debug+set}" = set; then :
2863    enableval=$enable_debug; debug=1
2864   fi
2865  
2866   if test "${DEBUG}"; then
2867  
2868 < cat >>confdefs.h <<\_ACEOF
2303 < #define debug 1
2304 < _ACEOF
2868 > $as_echo "#define debug 1" >>confdefs.h
2869  
2870    msg="$msg, debug mode"
2871   fi
2872  
2873  
2874   # Check whether --enable-single was given.
2875 < if test "${enable_single+set}" = set; then
2875 > if test "${enable_single+set}" = set; then :
2876    enableval=$enable_single; ok=$enableval
2877   else
2878    ok=no
2879   fi
2880  
2881   # Check whether --enable-float was given.
2882 < if test "${enable_float+set}" = set; then
2882 > if test "${enable_float+set}" = set; then :
2883    enableval=$enable_float; ok=$enableval
2884   fi
2885  
2886   if test "$ok" = "yes"; then
2887  
2888 < cat >>confdefs.h <<\_ACEOF
2325 < #define SINGLE_PRECISION 1
2326 < _ACEOF
2888 > $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
2889  
2890          USE_SINGLE_PRECISION=yes
2891  
2892   fi
2893  
2894 < if test x"$CC" != x; then
2895 <   for ac_prog in $CC
2896 < do
2897 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
2898 < set dummy $ac_prog; ac_word=$2
2899 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2894 > ac_ext=cpp
2895 > ac_cpp='$CXXCPP $CPPFLAGS'
2896 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2897 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2898 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2899 > if test -z "$CXX"; then
2900 >  if test -n "$CCC"; then
2901 >    CXX=$CCC
2902 >  else
2903 >    if test -n "$ac_tool_prefix"; then
2904 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2905 >  do
2906 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2907 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2908 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2909   $as_echo_n "checking for $ac_word... " >&6; }
2910 < if test "${ac_cv_prog_ac_cc_set+set}" = set; then
2910 > if ${ac_cv_prog_CXX+:} false; then :
2911    $as_echo_n "(cached) " >&6
2912   else
2913 <  if test -n "$ac_cc_set"; then
2914 <  ac_cv_prog_ac_cc_set="$ac_cc_set" # Let the user override the test.
2913 >  if test -n "$CXX"; then
2914 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2915   else
2916   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2917   for as_dir in $PATH
2918   do
2919    IFS=$as_save_IFS
2920    test -z "$as_dir" && as_dir=.
2921 <  for ac_exec_ext in '' $ac_executable_extensions; do
2921 >    for ac_exec_ext in '' $ac_executable_extensions; do
2922    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2923 <    ac_cv_prog_ac_cc_set="$ac_prog"
2924 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2923 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2924 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2925      break 2
2926    fi
2927   done
2928 < done
2928 >  done
2929   IFS=$as_save_IFS
2930  
2931   fi
2932   fi
2933 < ac_cc_set=$ac_cv_prog_ac_cc_set
2934 < if test -n "$ac_cc_set"; then
2935 <  { $as_echo "$as_me:$LINENO: result: $ac_cc_set" >&5
2936 < $as_echo "$ac_cc_set" >&6; }
2933 > CXX=$ac_cv_prog_CXX
2934 > if test -n "$CXX"; then
2935 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
2936 > $as_echo "$CXX" >&6; }
2937   else
2938 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2938 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2939   $as_echo "no" >&6; }
2940   fi
2941  
2942  
2943 <  test -n "$ac_cc_set" && break
2944 < 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
2943 >    test -n "$CXX" && break
2944 >  done
2945   fi
2946 < ac_cc_path=$ac_cv_path_ac_cc_path
2947 < if test -n "$ac_cc_path"; then
2948 <  { $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
2946 > if test -z "$CXX"; then
2947 >  ac_ct_CXX=$CXX
2948 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2949   do
2950    # Extract the first word of "$ac_prog", so it can be a program name with args.
2951   set dummy $ac_prog; ac_word=$2
2952 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2952 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2953   $as_echo_n "checking for $ac_word... " >&6; }
2954 < if test "${ac_cv_prog_ac_cxx_set+set}" = set; then
2954 > if ${ac_cv_prog_ac_ct_CXX+:} false; then :
2955    $as_echo_n "(cached) " >&6
2956   else
2957 <  if test -n "$ac_cxx_set"; then
2958 <  ac_cv_prog_ac_cxx_set="$ac_cxx_set" # Let the user override the test.
2957 >  if test -n "$ac_ct_CXX"; then
2958 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2959   else
2960   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2961   for as_dir in $PATH
2962   do
2963    IFS=$as_save_IFS
2964    test -z "$as_dir" && as_dir=.
2965 <  for ac_exec_ext in '' $ac_executable_extensions; do
2965 >    for ac_exec_ext in '' $ac_executable_extensions; do
2966    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2967 <    ac_cv_prog_ac_cxx_set="$ac_prog"
2968 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2967 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
2968 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2969      break 2
2970    fi
2971   done
2972 < done
2972 >  done
2973   IFS=$as_save_IFS
2974  
2975   fi
2976   fi
2977 < ac_cxx_set=$ac_cv_prog_ac_cxx_set
2978 < if test -n "$ac_cxx_set"; then
2979 <  { $as_echo "$as_me:$LINENO: result: $ac_cxx_set" >&5
2980 < $as_echo "$ac_cxx_set" >&6; }
2977 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2978 > if test -n "$ac_ct_CXX"; then
2979 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
2980 > $as_echo "$ac_ct_CXX" >&6; }
2981   else
2982 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2982 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2983   $as_echo "no" >&6; }
2984   fi
2985  
2986  
2987 <  test -n "$ac_cxx_set" && break
2987 >  test -n "$ac_ct_CXX" && break
2988   done
2482 – test -n "$ac_cxx_set" || ac_cxx_set="no"
2989  
2990 <   if test $ac_cxx_set != no; then
2990 >  if test "x$ac_ct_CXX" = x; then
2991 >    CXX="g++"
2992 >  else
2993 >    case $cross_compiling:$ac_tool_warned in
2994 > yes:)
2995 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
2996 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
2997 > ac_tool_warned=yes ;;
2998 > esac
2999 >    CXX=$ac_ct_CXX
3000 >  fi
3001 > fi
3002  
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
3003    fi
3004 + fi
3005 + # Provide some information about the compiler.
3006 + $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3007 + set X $ac_compile
3008 + ac_compiler=$2
3009 + for ac_option in --version -v -V -qversion; do
3010 +  { { ac_try="$ac_compiler $ac_option >&5"
3011 + case "(($ac_try" in
3012 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3013 +  *) ac_try_echo=$ac_try;;
3014 + esac
3015 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3016 + $as_echo "$ac_try_echo"; } >&5
3017 +  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3018 +  ac_status=$?
3019 +  if test -s conftest.err; then
3020 +    sed '10a\
3021 + ... rest of stderr output deleted ...
3022 +         10q' conftest.err >conftest.er1
3023 +    cat conftest.er1 >&5
3024 +  fi
3025 +  rm -f conftest.er1 conftest.err
3026 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3027 +  test $ac_status = 0; }
3028   done
2510 – done
2511 – IFS=$as_save_IFS
3029  
3030 <  test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
3031 <  ;;
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
3030 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3031 > /* end confdefs.h.  */
3032  
3033 + int
3034 + main ()
3035 + {
3036  
3037 < else
3037 >  ;
3038 >  return 0;
3039 > }
3040 > _ACEOF
3041 > ac_clean_files_save=$ac_clean_files
3042 > ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3043 > # Try to create an executable without -o first, disregard a.out.
3044 > # It will help us diagnose broken compilers, and finding out an intuition
3045 > # of exeext.
3046 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3047 > $as_echo_n "checking whether the C++ compiler works... " >&6; }
3048 > ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3049  
3050 <     { { $as_echo "$as_me:$LINENO: error: Specified C++ compiler $CXX doesn't seem to exist!" >&5
3051 < $as_echo "$as_me: error: Specified C++ compiler $CXX doesn't seem to exist!" >&2;}
2531 <   { (exit 1); exit 1; }; }
2532 < fi
3050 > # The possible output files:
3051 > ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3052  
3053 + ac_rmfiles=
3054 + for ac_file in $ac_files
3055 + do
3056 +  case $ac_file in
3057 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3058 +    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3059 +  esac
3060 + done
3061 + rm -f $ac_rmfiles
3062  
3063 <   if test $ac_cxx_path != no; then
3063 > if { { ac_try="$ac_link_default"
3064 > case "(($ac_try" in
3065 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3066 >  *) ac_try_echo=$ac_try;;
3067 > esac
3068 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3069 > $as_echo "$ac_try_echo"; } >&5
3070 >  (eval "$ac_link_default") 2>&5
3071 >  ac_status=$?
3072 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3073 >  test $ac_status = 0; }; then :
3074 >  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3075 > # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3076 > # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3077 > # so that the user can short-circuit this test for compilers unknown to
3078 > # Autoconf.
3079 > for ac_file in $ac_files ''
3080 > do
3081 >  test -f "$ac_file" || continue
3082 >  case $ac_file in
3083 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3084 >        ;;
3085 >    [ab].out )
3086 >        # We found the default executable, but exeext='' is most
3087 >        # certainly right.
3088 >        break;;
3089 >    *.* )
3090 >        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3091 >        then :; else
3092 >           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3093 >        fi
3094 >        # We set ac_cv_exeext here because the later test for it is not
3095 >        # safe: cross compilers may not add the suffix if given an `-o'
3096 >        # argument, so we may need to know it at that point already.
3097 >        # Even if this section looks crufty: it has the advantage of
3098 >        # actually working.
3099 >        break;;
3100 >    * )
3101 >        break;;
3102 >  esac
3103 > done
3104 > test "$ac_cv_exeext" = no && ac_cv_exeext=
3105  
2537 –     { $as_echo "$as_me:$LINENO: Will attempt to use $CXX as C++ compiler" >&5
2538 – $as_echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3106   else
3107 <
2541 <     { { $as_echo "$as_me:$LINENO: error: Can't find path to user-specified C++ compiler $CXX" >&5
2542 < $as_echo "$as_me: error: Can't find path to user-specified C++ compiler $CXX" >&2;}
2543 <   { (exit 1); exit 1; }; }
3107 >  ac_file=''
3108   fi
3109 + if test -z "$ac_file"; then :
3110 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3111 + $as_echo "no" >&6; }
3112 + $as_echo "$as_me: failed program was:" >&5
3113 + sed 's/^/| /' conftest.$ac_ext >&5
3114  
3115 + { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3116 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3117 + as_fn_error 77 "C++ compiler cannot create executables
3118 + See \`config.log' for more details" "$LINENO" 5; }
3119 + else
3120 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3121 + $as_echo "yes" >&6; }
3122   fi
3123 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3124 + $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3125 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3126 + $as_echo "$ac_file" >&6; }
3127 + ac_exeext=$ac_cv_exeext
3128  
3129 < if test x"$FC" != x; then
3130 <   for ac_prog in $FC
3131 < do
3132 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3133 < set dummy $ac_prog; ac_word=$2
3134 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3135 < $as_echo_n "checking for $ac_word... " >&6; }
3136 < if test "${ac_cv_prog_ac_fc_set+set}" = set; then
3137 <  $as_echo_n "(cached) " >&6
3138 < else
3139 <  if test -n "$ac_fc_set"; then
3140 <  ac_cv_prog_ac_fc_set="$ac_fc_set" # Let the user override the test.
3141 < else
3142 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3143 < for as_dir in $PATH
3144 < do
3145 <  IFS=$as_save_IFS
3146 <  test -z "$as_dir" && as_dir=.
3147 <  for ac_exec_ext in '' $ac_executable_extensions; do
3148 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3149 <    ac_cv_prog_ac_fc_set="$ac_prog"
3150 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3151 <    break 2
3152 <  fi
3129 > rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3130 > ac_clean_files=$ac_clean_files_save
3131 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3132 > $as_echo_n "checking for suffix of executables... " >&6; }
3133 > if { { ac_try="$ac_link"
3134 > case "(($ac_try" in
3135 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3136 >  *) ac_try_echo=$ac_try;;
3137 > esac
3138 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3139 > $as_echo "$ac_try_echo"; } >&5
3140 >  (eval "$ac_link") 2>&5
3141 >  ac_status=$?
3142 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3143 >  test $ac_status = 0; }; then :
3144 >  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3145 > # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3146 > # work properly (i.e., refer to `conftest.exe'), while it won't with
3147 > # `rm'.
3148 > for ac_file in conftest.exe conftest conftest.*; do
3149 >  test -f "$ac_file" || continue
3150 >  case $ac_file in
3151 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3152 >    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3153 >          break;;
3154 >    * ) break;;
3155 >  esac
3156   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; }
3157   else
3158 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3159 < $as_echo "no" >&6; }
3158 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3159 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3160 > as_fn_error $? "cannot compute suffix of executables: cannot compile and link
3161 > See \`config.log' for more details" "$LINENO" 5; }
3162   fi
3163 + rm -f conftest conftest$ac_cv_exeext
3164 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3165 + $as_echo "$ac_cv_exeext" >&6; }
3166  
3167 + rm -f conftest.$ac_ext
3168 + EXEEXT=$ac_cv_exeext
3169 + ac_exeext=$EXEEXT
3170 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3171 + /* end confdefs.h.  */
3172 + #include <stdio.h>
3173 + int
3174 + main ()
3175 + {
3176 + FILE *f = fopen ("conftest.out", "w");
3177 + return ferror (f) || fclose (f) != 0;
3178  
3179 <  test -n "$ac_fc_set" && break
3180 < done
3181 < test -n "$ac_fc_set" || ac_fc_set="no"
3179 >  ;
3180 >  return 0;
3181 > }
3182 > _ACEOF
3183 > ac_clean_files="$ac_clean_files conftest.out"
3184 > # Check that the compiler produces executables we can run.  If not, either
3185 > # the compiler is broken, or we cross compile.
3186 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3187 > $as_echo_n "checking whether we are cross compiling... " >&6; }
3188 > if test "$cross_compiling" != yes; then
3189 >  { { ac_try="$ac_link"
3190 > case "(($ac_try" in
3191 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3192 >  *) ac_try_echo=$ac_try;;
3193 > esac
3194 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3195 > $as_echo "$ac_try_echo"; } >&5
3196 >  (eval "$ac_link") 2>&5
3197 >  ac_status=$?
3198 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3199 >  test $ac_status = 0; }
3200 >  if { ac_try='./conftest$ac_cv_exeext'
3201 >  { { case "(($ac_try" in
3202 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3203 >  *) ac_try_echo=$ac_try;;
3204 > esac
3205 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3206 > $as_echo "$ac_try_echo"; } >&5
3207 >  (eval "$ac_try") 2>&5
3208 >  ac_status=$?
3209 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3210 >  test $ac_status = 0; }; }; then
3211 >    cross_compiling=no
3212 >  else
3213 >    if test "$cross_compiling" = maybe; then
3214 >        cross_compiling=yes
3215 >    else
3216 >        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3217 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3218 > as_fn_error $? "cannot run C++ compiled programs.
3219 > If you meant to cross compile, use \`--host'.
3220 > See \`config.log' for more details" "$LINENO" 5; }
3221 >    fi
3222 >  fi
3223 > fi
3224 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3225 > $as_echo "$cross_compiling" >&6; }
3226  
3227 <   if test $ac_fc_set != no; then
3228 <
3229 <     # Extract the first word of "$ac_fc_set", so it can be a program name with args.
3230 < set dummy $ac_fc_set; ac_word=$2
3231 < { $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
3227 > rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3228 > ac_clean_files=$ac_clean_files_save
3229 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3230 > $as_echo_n "checking for suffix of object files... " >&6; }
3231 > if ${ac_cv_objext+:} false; then :
3232    $as_echo_n "(cached) " >&6
3233   else
3234 <  case $ac_fc_path in
3235 <  [\\/]* | ?:[\\/]*)
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
3234 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3235 > /* end confdefs.h.  */
3236  
3237 <  test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
3238 <  ;;
3237 > int
3238 > main ()
3239 > {
3240 >
3241 >  ;
3242 >  return 0;
3243 > }
3244 > _ACEOF
3245 > rm -f conftest.o conftest.obj
3246 > if { { ac_try="$ac_compile"
3247 > case "(($ac_try" in
3248 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3249 >  *) ac_try_echo=$ac_try;;
3250   esac
3251 < fi
3252 < ac_fc_path=$ac_cv_path_ac_fc_path
3253 < if test -n "$ac_fc_path"; then
3254 <  { $as_echo "$as_me:$LINENO: result: $ac_fc_path" >&5
3255 < $as_echo "$ac_fc_path" >&6; }
3251 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3252 > $as_echo "$ac_try_echo"; } >&5
3253 >  (eval "$ac_compile") 2>&5
3254 >  ac_status=$?
3255 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3256 >  test $ac_status = 0; }; then :
3257 >  for ac_file in conftest.o conftest.obj conftest.*; do
3258 >  test -f "$ac_file" || continue;
3259 >  case $ac_file in
3260 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3261 >    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3262 >       break;;
3263 >  esac
3264 > done
3265   else
3266 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3267 < $as_echo "no" >&6; }
3266 >  $as_echo "$as_me: failed program was:" >&5
3267 > sed 's/^/| /' conftest.$ac_ext >&5
3268 >
3269 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3270 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3271 > as_fn_error $? "cannot compute suffix of object files: cannot compile
3272 > See \`config.log' for more details" "$LINENO" 5; }
3273   fi
3274 + rm -f conftest.$ac_cv_objext conftest.$ac_ext
3275 + fi
3276 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3277 + $as_echo "$ac_cv_objext" >&6; }
3278 + OBJEXT=$ac_cv_objext
3279 + ac_objext=$OBJEXT
3280 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3281 + $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3282 + if ${ac_cv_cxx_compiler_gnu+:} false; then :
3283 +  $as_echo_n "(cached) " >&6
3284 + else
3285 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3286 + /* end confdefs.h.  */
3287  
3288 + int
3289 + main ()
3290 + {
3291 + #ifndef __GNUC__
3292 +       choke me
3293 + #endif
3294  
3295 +  ;
3296 +  return 0;
3297 + }
3298 + _ACEOF
3299 + if ac_fn_cxx_try_compile "$LINENO"; then :
3300 +  ac_compiler_gnu=yes
3301   else
3302 <
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; }; }
3302 >  ac_compiler_gnu=no
3303   fi
3304 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3305 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3306  
3307 <
3308 <   if test $ac_fc_path != no; then
3309 <
3310 <     { $as_echo "$as_me:$LINENO: Will attempt to use $FC as Fortran compiler" >&5
3311 < $as_echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3307 > fi
3308 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3309 > $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3310 > if test $ac_compiler_gnu = yes; then
3311 >  GXX=yes
3312   else
3313 <
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; }; }
3313 >  GXX=
3314   fi
3315 + ac_test_CXXFLAGS=${CXXFLAGS+set}
3316 + ac_save_CXXFLAGS=$CXXFLAGS
3317 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3318 + $as_echo_n "checking whether $CXX accepts -g... " >&6; }
3319 + if ${ac_cv_prog_cxx_g+:} false; then :
3320 +  $as_echo_n "(cached) " >&6
3321 + else
3322 +  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3323 +   ac_cxx_werror_flag=yes
3324 +   ac_cv_prog_cxx_g=no
3325 +   CXXFLAGS="-g"
3326 +   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3327 + /* end confdefs.h.  */
3328  
3329 < fi
3329 > int
3330 > main ()
3331 > {
3332  
3333 <
3334 <
3335 <
3336 < # Check whether --with-mpi was given.
3337 < if test "${with_mpi+set}" = set; then
3338 <  withval=$with_mpi;
3333 >  ;
3334 >  return 0;
3335 > }
3336 > _ACEOF
3337 > if ac_fn_cxx_try_compile "$LINENO"; then :
3338 >  ac_cv_prog_cxx_g=yes
3339   else
3340 <  with_mpi="auto"
3341 < fi
3340 >  CXXFLAGS=""
3341 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3342 > /* end confdefs.h.  */
3343  
3344 < if test "x$with_mpi" != "xno"; then
3344 > int
3345 > main ()
3346 > {
3347  
3348 +  ;
3349 +  return 0;
3350 + }
3351 + _ACEOF
3352 + if ac_fn_cxx_try_compile "$LINENO"; then :
3353  
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
3354   else
3355 <  if test -n "$acx_mpi_mpicc"; then
3356 <  ac_cv_prog_acx_mpi_mpicc="$acx_mpi_mpicc" # Let the user override the test.
3357 < else
3358 < 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
3355 >  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3356 >         CXXFLAGS="-g"
3357 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3358 > /* end confdefs.h.  */
3359  
3360 + int
3361 + main ()
3362 + {
3363 +
3364 +  ;
3365 +  return 0;
3366 + }
3367 + _ACEOF
3368 + if ac_fn_cxx_try_compile "$LINENO"; then :
3369 +  ac_cv_prog_cxx_g=yes
3370   fi
3371 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3372   fi
3373 < 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; }
3373 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3374   fi
3375 <
3376 <
3377 <  test -n "$acx_mpi_mpicc" && break
3378 < done
3379 < test -n "$acx_mpi_mpicc" || acx_mpi_mpicc="no"
3380 <
3381 < if test $acx_mpi_mpicc != no; then
3382 <
3383 <  # Extract the first word of "$acx_mpi_mpicc", so it can be a program name with args.
3384 < set dummy $acx_mpi_mpicc; ac_word=$2
3385 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3386 < $as_echo_n "checking for $ac_word... " >&6; }
3387 < if test "${ac_cv_path_acx_mpi_mpicc_path+set}" = set; then
2719 <  $as_echo_n "(cached) " >&6
3375 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3376 >   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3377 > fi
3378 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3379 > $as_echo "$ac_cv_prog_cxx_g" >&6; }
3380 > if test "$ac_test_CXXFLAGS" = set; then
3381 >  CXXFLAGS=$ac_save_CXXFLAGS
3382 > elif test $ac_cv_prog_cxx_g = yes; then
3383 >  if test "$GXX" = yes; then
3384 >    CXXFLAGS="-g -O2"
3385 >  else
3386 >    CXXFLAGS="-g"
3387 >  fi
3388   else
3389 <  case $acx_mpi_mpicc_path in
3390 <  [\\/]* | ?:[\\/]*)
3391 <  ac_cv_path_acx_mpi_mpicc_path="$acx_mpi_mpicc_path" # Let the user override the test with a path.
3392 <  ;;
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
3389 >  if test "$GXX" = yes; then
3390 >    CXXFLAGS="-O2"
3391 >  else
3392 >    CXXFLAGS=
3393    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
3394   fi
3395 < acx_mpi_mpicc_path=$ac_cv_path_acx_mpi_mpicc_path
3396 < if test -n "$acx_mpi_mpicc_path"; then
3397 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicc_path" >&5
3398 < $as_echo "$acx_mpi_mpicc_path" >&6; }
3399 < else
2750 <  { $as_echo "$as_me:$LINENO: result: no" >&5
2751 < $as_echo "no" >&6; }
2752 < fi
3395 > ac_ext=c
3396 > ac_cpp='$CPP $CPPFLAGS'
3397 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3398 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3399 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3400  
3401 <
3402 < fi
3403 <
3404 < for ac_prog in $FC openmpif90 mpif90
3405 < do
3406 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3407 < set dummy $ac_prog; ac_word=$2
3408 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3401 > ac_ext=c
3402 > ac_cpp='$CPP $CPPFLAGS'
3403 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3404 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3405 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3406 > if test -n "$ac_tool_prefix"; then
3407 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3408 >  do
3409 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3410 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3411 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3412   $as_echo_n "checking for $ac_word... " >&6; }
3413 < if test "${ac_cv_prog_acx_mpi_mpif90+set}" = set; then
3413 > if ${ac_cv_prog_CC+:} false; then :
3414    $as_echo_n "(cached) " >&6
3415   else
3416 <  if test -n "$acx_mpi_mpif90"; then
3417 <  ac_cv_prog_acx_mpi_mpif90="$acx_mpi_mpif90" # Let the user override the test.
3416 >  if test -n "$CC"; then
3417 >  ac_cv_prog_CC="$CC" # Let the user override the test.
3418   else
3419   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3420   for as_dir in $PATH
3421   do
3422    IFS=$as_save_IFS
3423    test -z "$as_dir" && as_dir=.
3424 <  for ac_exec_ext in '' $ac_executable_extensions; do
3424 >    for ac_exec_ext in '' $ac_executable_extensions; do
3425    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3426 <    ac_cv_prog_acx_mpi_mpif90="$ac_prog"
3427 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3426 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3427 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3428      break 2
3429    fi
3430   done
3431 < done
3431 >  done
3432   IFS=$as_save_IFS
3433  
3434   fi
3435   fi
3436 < acx_mpi_mpif90=$ac_cv_prog_acx_mpi_mpif90
3437 < if test -n "$acx_mpi_mpif90"; then
3438 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpif90" >&5
3439 < $as_echo "$acx_mpi_mpif90" >&6; }
3436 > CC=$ac_cv_prog_CC
3437 > if test -n "$CC"; then
3438 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3439 > $as_echo "$CC" >&6; }
3440   else
3441 <  { $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
3441 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3442   $as_echo "no" >&6; }
3443   fi
3444  
3445  
3446 +    test -n "$CC" && break
3447 +  done
3448   fi
3449 <
3450 < for ac_prog in $CXX openmpicxx openmpiCC openmpic++ mpicxx mpiCC mpic++
3449 > if test -z "$CC"; then
3450 >  ac_ct_CC=$CC
3451 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3452   do
3453    # Extract the first word of "$ac_prog", so it can be a program name with args.
3454   set dummy $ac_prog; ac_word=$2
3455 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3455 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3456   $as_echo_n "checking for $ac_word... " >&6; }
3457 < if test "${ac_cv_prog_acx_mpi_mpicxx+set}" = set; then
3457 > if ${ac_cv_prog_ac_ct_CC+:} false; then :
3458    $as_echo_n "(cached) " >&6
3459   else
3460 <  if test -n "$acx_mpi_mpicxx"; then
3461 <  ac_cv_prog_acx_mpi_mpicxx="$acx_mpi_mpicxx" # Let the user override the test.
3460 >  if test -n "$ac_ct_CC"; then
3461 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3462   else
3463   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3464   for as_dir in $PATH
3465   do
3466    IFS=$as_save_IFS
3467    test -z "$as_dir" && as_dir=.
3468 <  for ac_exec_ext in '' $ac_executable_extensions; do
3468 >    for ac_exec_ext in '' $ac_executable_extensions; do
3469    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3470 <    ac_cv_prog_acx_mpi_mpicxx="$ac_prog"
3471 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3470 >    ac_cv_prog_ac_ct_CC="$ac_prog"
3471 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3472      break 2
3473    fi
3474   done
3475 < done
3475 >  done
3476   IFS=$as_save_IFS
3477  
3478   fi
3479   fi
3480 < acx_mpi_mpicxx=$ac_cv_prog_acx_mpi_mpicxx
3481 < if test -n "$acx_mpi_mpicxx"; then
3482 <  { $as_echo "$as_me:$LINENO: result: $acx_mpi_mpicxx" >&5
3483 < $as_echo "$acx_mpi_mpicxx" >&6; }
3480 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
3481 > if test -n "$ac_ct_CC"; then
3482 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3483 > $as_echo "$ac_ct_CC" >&6; }
3484   else
3485 <  { $as_echo "$as_me:$LINENO: result: no" >&5
3485 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3486   $as_echo "no" >&6; }
3487   fi
3488  
3489  
3490 <  test -n "$acx_mpi_mpicxx" && break
3490 >  test -n "$ac_ct_CC" && break
3491   done
2886 – test -n "$acx_mpi_mpicxx" || acx_mpi_mpicxx="no"
3492  
3493 < if test $acx_mpi_mpicxx != no; then
3494 <
3495 <  # Extract the first word of "$acx_mpi_mpicxx", so it can be a program name with args.
3496 < set dummy $acx_mpi_mpicxx; ac_word=$2
3497 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3498 < $as_echo_n "checking for $ac_word... " >&6; }
3499 < if test "${ac_cv_path_acx_mpi_mpicxx_path+set}" = set; then
3500 <  $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 <  ;;
3493 >  if test "x$ac_ct_CC" = x; then
3494 >    CC=""
3495 >  else
3496 >    case $cross_compiling:$ac_tool_warned in
3497 > yes:)
3498 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3499 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3500 > ac_tool_warned=yes ;;
3501   esac
3502 +    CC=$ac_ct_CC
3503 +  fi
3504   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
3505  
3506  
3507 < fi
3507 > test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3508 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3509 > as_fn_error $? "no acceptable C compiler found in \$PATH
3510 > See \`config.log' for more details" "$LINENO" 5; }
3511  
3512 < if test $acx_mpi_mpicc = no; then
3512 > # Provide some information about the compiler.
3513 > $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
3514 > set X $ac_compile
3515 > ac_compiler=$2
3516 > for ac_option in --version -v -V -qversion; do
3517 >  { { ac_try="$ac_compiler $ac_option >&5"
3518 > case "(($ac_try" in
3519 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3520 >  *) ac_try_echo=$ac_try;;
3521 > esac
3522 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3523 > $as_echo "$ac_try_echo"; } >&5
3524 >  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3525 >  ac_status=$?
3526 >  if test -s conftest.err; then
3527 >    sed '10a\
3528 > ... rest of stderr output deleted ...
3529 >         10q' conftest.err >conftest.er1
3530 >    cat conftest.er1 >&5
3531 >  fi
3532 >  rm -f conftest.er1 conftest.err
3533 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3534 >  test $ac_status = 0; }
3535 > done
3536  
3537 <  if test $acx_mpi_mpicxx = no; then
3537 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
3538 > $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3539 > if ${ac_cv_c_compiler_gnu+:} false; then :
3540 >  $as_echo_n "(cached) " >&6
3541 > else
3542 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3543 > /* end confdefs.h.  */
3544  
3545 <    acx_mpi_compiler=no
3545 > int
3546 > main ()
3547 > {
3548 > #ifndef __GNUC__
3549 >       choke me
3550 > #endif
3551  
3552 +  ;
3553 +  return 0;
3554 + }
3555 + _ACEOF
3556 + if ac_fn_c_try_compile "$LINENO"; then :
3557 +  ac_compiler_gnu=yes
3558   else
3559 <
2941 <    acx_mpi_compiler=$acx_mpi_mpicxx
2942 <    acx_mpi_compiler_path=$acx_mpi_mpicxx_path
3559 >  ac_compiler_gnu=no
3560   fi
3561 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3562 + ac_cv_c_compiler_gnu=$ac_compiler_gnu
3563  
3564 <
3564 > fi
3565 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
3566 > $as_echo "$ac_cv_c_compiler_gnu" >&6; }
3567 > if test $ac_compiler_gnu = yes; then
3568 >  GCC=yes
3569   else
3570 <
3571 <  if test $acx_mpi_mpicxx = no; then
3572 <
3573 <    acx_mpi_compiler=$acx_mpi_mpicc
3574 <    acx_mpi_compiler_path=$acx_mpi_mpicc_path
3575 <
3570 >  GCC=
3571 > fi
3572 > ac_test_CFLAGS=${CFLAGS+set}
3573 > ac_save_CFLAGS=$CFLAGS
3574 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
3575 > $as_echo_n "checking whether $CC accepts -g... " >&6; }
3576 > if ${ac_cv_prog_cc_g+:} false; then :
3577 >  $as_echo_n "(cached) " >&6
3578   else
3579 <
3580 <    { $as_echo "$as_me:$LINENO: checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx" >&5
3581 < $as_echo_n "checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx... " >&6; }
3582 <    ac_ext=cpp
3583 < 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
3579 >  ac_save_c_werror_flag=$ac_c_werror_flag
3580 >   ac_c_werror_flag=yes
3581 >   ac_cv_prog_cc_g=no
3582 >   CFLAGS="-g"
3583 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3584   /* end confdefs.h.  */
3585  
2970 – #include <mpi.h>
2971 –
3586   int
3587   main ()
3588   {
3589  
2976 – MPI_Finalize();
2977 –
3590    ;
3591    return 0;
3592   }
3593   _ACEOF
3594 <    if { (ac_try="$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5"
3595 < case "(($ac_try" in
3596 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3597 <  *) ac_try_echo=$ac_try;;
3598 < esac
3599 < 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
3594 > if ac_fn_c_try_compile "$LINENO"; then :
3595 >  ac_cv_prog_cc_g=yes
3596 > else
3597 >  CFLAGS=""
3598 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3599 > /* end confdefs.h.  */
3600  
3601 <      acx_mpi_compiler=$acx_mpi_mpicxx
3602 <      acx_mpi_compiler_path=$acx_mpi_mpicxx_path
3601 > int
3602 > main ()
3603 > {
3604  
3605 +  ;
3606 +  return 0;
3607 + }
3608 + _ACEOF
3609 + if ac_fn_c_try_compile "$LINENO"; then :
3610 +
3611   else
3612 +  ac_c_werror_flag=$ac_save_c_werror_flag
3613 +         CFLAGS="-g"
3614 +         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3615 + /* end confdefs.h.  */
3616  
3617 <      acx_mpi_compiler=$acx_mpi_mpicc
3618 <      acx_mpi_compiler_path=$acx_mpi_mpicc_path
3617 > int
3618 > main ()
3619 > {
3620 >
3621 >  ;
3622 >  return 0;
3623 > }
3624 > _ACEOF
3625 > if ac_fn_c_try_compile "$LINENO"; then :
3626 >  ac_cv_prog_cc_g=yes
3627   fi
3628 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3629 + fi
3630 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3631 + fi
3632 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3633 +   ac_c_werror_flag=$ac_save_c_werror_flag
3634 + fi
3635 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
3636 + $as_echo "$ac_cv_prog_cc_g" >&6; }
3637 + if test "$ac_test_CFLAGS" = set; then
3638 +  CFLAGS=$ac_save_CFLAGS
3639 + elif test $ac_cv_prog_cc_g = yes; then
3640 +  if test "$GCC" = yes; then
3641 +    CFLAGS="-g -O2"
3642 +  else
3643 +    CFLAGS="-g"
3644 +  fi
3645 + else
3646 +  if test "$GCC" = yes; then
3647 +    CFLAGS="-O2"
3648 +  else
3649 +    CFLAGS=
3650 +  fi
3651 + fi
3652 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
3653 + $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
3654 + if ${ac_cv_prog_cc_c89+:} false; then :
3655 +  $as_echo_n "(cached) " >&6
3656 + else
3657 +  ac_cv_prog_cc_c89=no
3658 + ac_save_CC=$CC
3659 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3660 + /* end confdefs.h.  */
3661 + #include <stdarg.h>
3662 + #include <stdio.h>
3663 + #include <sys/types.h>
3664 + #include <sys/stat.h>
3665 + /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3666 + struct buf { int x; };
3667 + FILE * (*rcsopen) (struct buf *, struct stat *, int);
3668 + static char *e (p, i)
3669 +     char **p;
3670 +     int i;
3671 + {
3672 +  return p[i];
3673 + }
3674 + static char *f (char * (*g) (char **, int), char **p, ...)
3675 + {
3676 +  char *s;
3677 +  va_list v;
3678 +  va_start (v,p);
3679 +  s = g (p, va_arg (v,int));
3680 +  va_end (v);
3681 +  return s;
3682 + }
3683  
3684 <    ac_ext=c
3685 < ac_cpp='$CPP $CPPFLAGS'
3686 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3687 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3688 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3684 > /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3685 >   function prototypes and stuff, but not '\xHH' hex character constants.
3686 >   These don't provoke an error unfortunately, instead are silently treated
3687 >   as 'x'.  The following induces an error, until -std is added to get
3688 >   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3689 >   array size at least.  It's necessary to write '\x00'==0 to get something
3690 >   that's true only with -std.  */
3691 > int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3692  
3693 <    { $as_echo "$as_me:$LINENO: result: $acx_mpi_compiler" >&5
3694 < $as_echo "$acx_mpi_compiler" >&6; }
3693 > /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
3694 >   inside strings and character constants.  */
3695 > #define FOO(x) 'x'
3696 > int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
3697 >
3698 > int test (int i, double x);
3699 > struct s1 {int (*f) (int a);};
3700 > struct s2 {int (*f) (double a);};
3701 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3702 > int argc;
3703 > char **argv;
3704 > int
3705 > main ()
3706 > {
3707 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3708 >  ;
3709 >  return 0;
3710 > }
3711 > _ACEOF
3712 > for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
3713 >        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3714 > do
3715 >  CC="$ac_save_CC $ac_arg"
3716 >  if ac_fn_c_try_compile "$LINENO"; then :
3717 >  ac_cv_prog_cc_c89=$ac_arg
3718   fi
3719 + rm -f core conftest.err conftest.$ac_objext
3720 +  test "x$ac_cv_prog_cc_c89" != "xno" && break
3721 + done
3722 + rm -f conftest.$ac_ext
3723 + CC=$ac_save_CC
3724  
3725   fi
3726 + # AC_CACHE_VAL
3727 + case "x$ac_cv_prog_cc_c89" in
3728 +  x)
3729 +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
3730 + $as_echo "none needed" >&6; } ;;
3731 +  xno)
3732 +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
3733 + $as_echo "unsupported" >&6; } ;;
3734 +  *)
3735 +    CC="$CC $ac_cv_prog_cc_c89"
3736 +    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
3737 + $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
3738 + esac
3739 + if test "x$ac_cv_prog_cc_c89" != xno; then :
3740  
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; }
3741   fi
3742 < rm -f conftest*
3050 < ac_ext=$ac_save_ext
3742 >
3743   ac_ext=c
3744   ac_cpp='$CPP $CPPFLAGS'
3745   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3746   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3747   ac_compiler_gnu=$ac_cv_c_compiler_gnu
3748  
3057 – if test $acx_mpi_compiler = no || test $acx_mpi_f90_compiler = no; then
3749  
3750 < acx_cv_mpi_implementation=no
3751 < else
3752 <  { $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
3750 > save_CXX=$CXX
3751 > save_CC=$CC
3752 > save_LIBS=$LIBS
3753  
3754 <  acx_cv_mpi_implementation=lammpi
3754 > ac_ext=cpp
3755 > ac_cpp='$CXXCPP $CPPFLAGS'
3756 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3757 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3758 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3759  
3084 – else
3760  
3761 <  if { (ac_try="grep -q showme $acx_mpi_compiler_path"
3762 < case "(($ac_try" in
3763 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3764 <  *) 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 <
3761 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
3762 > $as_echo_n "checking for dlopen in -lc... " >&6; }
3763 > if ${ac_cv_lib_c_dlopen+:} false; then :
3764 >  $as_echo_n "(cached) " >&6
3765   else
3766 +  ac_check_lib_save_LIBS=$LIBS
3767 + LIBS="-lc  $LIBS"
3768 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3769 + /* end confdefs.h.  */
3770  
3771 <    if { (ac_try="grep -q MPICH $acx_mpi_compiler_path"
3772 < case "(($ac_try" in
3773 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3774 <  *) ac_try_echo=$ac_try;;
3775 < esac
3776 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3777 < $as_echo "$ac_try_echo") >&5
3778 <  (eval "grep -q MPICH $acx_mpi_compiler_path") 2>conftest.er1
3779 <  ac_status=$?
3780 <  grep -v '^ *+' conftest.er1 >conftest.err
3781 <  rm -f conftest.er1
3782 <  cat conftest.err >&5
3783 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3784 <  (exit $ac_status); }; then
3785 <
3786 <      acx_cv_mpi_implementation=mpich
3787 <
3788 < else
3789 <  acx_cv_mpi_implementation=$with_mpi
3124 < fi
3125 <
3771 > /* Override any GCC internal prototype to avoid an error.
3772 >   Use char because int might match the return type of a GCC
3773 >   builtin and then its argument prototype would still apply.  */
3774 > #ifdef __cplusplus
3775 > extern "C"
3776 > #endif
3777 > char dlopen ();
3778 > int
3779 > main ()
3780 > {
3781 > return dlopen ();
3782 >  ;
3783 >  return 0;
3784 > }
3785 > _ACEOF
3786 > if ac_fn_cxx_try_link "$LINENO"; then :
3787 >  ac_cv_lib_c_dlopen=yes
3788 > else
3789 >  ac_cv_lib_c_dlopen=no
3790   fi
3791 <
3791 > rm -f core conftest.err conftest.$ac_objext \
3792 >    conftest$ac_exeext conftest.$ac_ext
3793 > LIBS=$ac_check_lib_save_LIBS
3794   fi
3795 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
3796 + $as_echo "$ac_cv_lib_c_dlopen" >&6; }
3797 + if test "x$ac_cv_lib_c_dlopen" = xyes; then :
3798 +  LIBDL=""
3799 + else
3800 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
3801 + $as_echo_n "checking for dlopen in -ldl... " >&6; }
3802 + if ${ac_cv_lib_dl_dlopen+:} false; then :
3803 +  $as_echo_n "(cached) " >&6
3804 + else
3805 +  ac_check_lib_save_LIBS=$LIBS
3806 + LIBS="-ldl  $LIBS"
3807 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3808 + /* end confdefs.h.  */
3809  
3810 + /* Override any GCC internal prototype to avoid an error.
3811 +   Use char because int might match the return type of a GCC
3812 +   builtin and then its argument prototype would still apply.  */
3813 + #ifdef __cplusplus
3814 + extern "C"
3815 + #endif
3816 + char dlopen ();
3817 + int
3818 + main ()
3819 + {
3820 + return dlopen ();
3821 +  ;
3822 +  return 0;
3823 + }
3824 + _ACEOF
3825 + if ac_fn_cxx_try_link "$LINENO"; then :
3826 +  ac_cv_lib_dl_dlopen=yes
3827 + else
3828 +  ac_cv_lib_dl_dlopen=no
3829   fi
3830 < { $as_echo "$as_me:$LINENO: result: $acx_cv_mpi_implementation" >&5
3831 < $as_echo "$acx_cv_mpi_implementation" >&6; }
3830 > rm -f core conftest.err conftest.$ac_objext \
3831 >    conftest$ac_exeext conftest.$ac_ext
3832 > LIBS=$ac_check_lib_save_LIBS
3833 > fi
3834 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
3835 > $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
3836 > if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
3837 >  LIBDL="-ldl"
3838 > fi
3839  
3840   fi
3135 – case $acx_cv_mpi_implementation in
3136 – (lammpi)
3841  
3138 – cat >>confdefs.h <<\_ACEOF
3139 – #define MPI_IS_LAMMPI 1
3140 – _ACEOF
3842  
3142 –  ;;
3143 – (openmpi)
3843  
3145 – cat >>confdefs.h <<\_ACEOF
3146 – #define MPI_IS_OPENMPI 1
3147 – _ACEOF
3844  
3149 –  ;;
3150 – (mpich)
3845  
3152 – cat >>confdefs.h <<\_ACEOF
3153 – #define MPI_IS_MPICH 1
3154 – _ACEOF
3846  
3156 –  ;;
3157 – esac
3158 – if test $acx_cv_mpi_implementation = no; then
3847  
3848 < acx_mpi_cflags=""
3849 < acx_mpi_libs=""
3850 < USE_MPI="no"
3851 <        { $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3852 < $as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3848 >        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3849 > do
3850 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
3851 > set dummy $ac_prog; ac_word=$2
3852 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3853 > $as_echo_n "checking for $ac_word... " >&6; }
3854 > if ${ac_cv_prog_MPICXX+:} false; then :
3855 >  $as_echo_n "(cached) " >&6
3856   else
3857 +  if test -n "$MPICXX"; then
3858 +  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3859 + else
3860 + as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3861 + for as_dir in $PATH
3862 + do
3863 +  IFS=$as_save_IFS
3864 +  test -z "$as_dir" && as_dir=.
3865 +    for ac_exec_ext in '' $ac_executable_extensions; do
3866 +  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3867 +    ac_cv_prog_MPICXX="$ac_prog"
3868 +    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3869 +    break 2
3870 +  fi
3871 + done
3872 +  done
3873 + IFS=$as_save_IFS
3874  
3875 <
3876 < { $as_echo "$as_me:$LINENO: checking how to compile MPI-C code" >&5
3877 < $as_echo_n "checking how to compile MPI-C code... " >&6; }
3878 < if test "${acx_mpi_cflags+set}" = set; then
3879 <  $as_echo_n "(cached) " >&6
3875 > fi
3876 > fi
3877 > MPICXX=$ac_cv_prog_MPICXX
3878 > if test -n "$MPICXX"; then
3879 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3880 > $as_echo "$MPICXX" >&6; }
3881   else
3882 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3883 + $as_echo "no" >&6; }
3884 + fi
3885  
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
3886  
3887 <    ;;
3888 < esac
3887 >  test -n "$MPICXX" && break
3888 > done
3889 > test -n "$MPICXX" || MPICXX="$CXX"
3890  
3891 +        ax_mpi_save_CXX="$CXX"
3892 +        CXX="$MPICXX"
3893 +
3894 +
3895 +
3896 + if test x = x"$MPILIBS"; then
3897 +        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3898 + if test "x$ac_cv_func_MPI_Init" = xyes; then :
3899 +  MPILIBS=" "
3900   fi
3246 – { $as_echo "$as_me:$LINENO: result: $acx_mpi_cflags" >&5
3247 – $as_echo "$acx_mpi_cflags" >&6; }
3901  
3902 + fi
3903  
3904 < { $as_echo "$as_me:$LINENO: checking how to link MPI-C code" >&5
3905 < $as_echo_n "checking how to link MPI-C code... " >&6; }
3906 < if test "${acx_mpi_libs+set}" = set; then
3904 > if test x = x"$MPILIBS"; then
3905 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3906 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3907 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
3908    $as_echo_n "(cached) " >&6
3909   else
3910 +  ac_check_lib_save_LIBS=$LIBS
3911 + LIBS="-lmpi  $LIBS"
3912 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3913 + /* end confdefs.h.  */
3914  
3915 < case $acx_cv_mpi_implementation in
3916 <  (lammpi)
3917 <    lfo="--showme:compile --showme:link"
3918 <    ;;
3919 <  (openmpi)
3920 <    lfo="--showme:link"
3921 <    ;;
3922 <  (mpich)
3923 <    case "$acx_mpi_compiler_path" in
3924 <      (*mpiCC)
3925 <        sc_cv_cn="-CC="
3926 <        ;;
3927 <      (*mpicxx)
3928 <        sc_cv_cn="-cxx="
3929 <        ;;
3930 <      (*mpicc)
3931 <        sc_cv_cn="-cc="
3932 <        ;;
3933 <      (*)
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 <
3915 > /* Override any GCC internal prototype to avoid an error.
3916 >   Use char because int might match the return type of a GCC
3917 >   builtin and then its argument prototype would still apply.  */
3918 > #ifdef __cplusplus
3919 > extern "C"
3920 > #endif
3921 > char MPI_Init ();
3922 > int
3923 > main ()
3924 > {
3925 > return MPI_Init ();
3926 >  ;
3927 >  return 0;
3928 > }
3929 > _ACEOF
3930 > if ac_fn_cxx_try_link "$LINENO"; then :
3931 >  ac_cv_lib_mpi_MPI_Init=yes
3932 > else
3933 >  ac_cv_lib_mpi_MPI_Init=no
3934   fi
3935 < { $as_echo "$as_me:$LINENO: result: $acx_mpi_libs" >&5
3936 < $as_echo "$acx_mpi_libs" >&6; }
3935 > rm -f core conftest.err conftest.$ac_objext \
3936 >    conftest$ac_exeext conftest.$ac_ext
3937 > LIBS=$ac_check_lib_save_LIBS
3938 > fi
3939 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3940 > $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3941 > if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
3942 >  MPILIBS="-lmpi"
3943 > fi
3944  
3945 < if test $acx_mpi_mpif90_path != no; then
3946 <
3947 <
3948 <  { $as_echo "$as_me:$LINENO: checking how to link MPI-Fortran code" >&5
3949 < $as_echo_n "checking how to link MPI-Fortran code... " >&6; }
3305 < if test "${acx_mpi90_libs+set}" = set; then
3945 > fi
3946 > if test x = x"$MPILIBS"; then
3947 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3948 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3949 > if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
3950    $as_echo_n "(cached) " >&6
3951   else
3952 +  ac_check_lib_save_LIBS=$LIBS
3953 + LIBS="-lmpich  $LIBS"
3954 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3955 + /* end confdefs.h.  */
3956  
3957 <    $as_echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_mpif90_path $lfo || echo \" no\"\`\"" >&5
3958 <    mpi_pre_libs="`$acx_mpi_mpif90_path $lfo 2>conftest.er1 || echo " no"`"
3959 <    grep -v '^ *+' conftest.er1 >conftest.err
3960 <    rm -f conftest.er1
3961 <    cat conftest.err >&5
3962 <    $as_echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3963 <    case "$mpi_pre_libs" in
3964 <      (*no)
3965 <        acx_mpi90_libs=no
3966 <        ;;
3967 <      (*)
3968 <        acx_mpi90_libs="$mpi_pre_libs"
3969 <        ;;
3970 <    esac
3971 <
3957 > /* Override any GCC internal prototype to avoid an error.
3958 >   Use char because int might match the return type of a GCC
3959 >   builtin and then its argument prototype would still apply.  */
3960 > #ifdef __cplusplus
3961 > extern "C"
3962 > #endif
3963 > char MPI_Init ();
3964 > int
3965 > main ()
3966 > {
3967 > return MPI_Init ();
3968 >  ;
3969 >  return 0;
3970 > }
3971 > _ACEOF
3972 > if ac_fn_cxx_try_link "$LINENO"; then :
3973 >  ac_cv_lib_mpich_MPI_Init=yes
3974 > else
3975 >  ac_cv_lib_mpich_MPI_Init=no
3976   fi
3977 < { $as_echo "$as_me:$LINENO: result: $acx_mpi90_libs" >&5
3978 < $as_echo "$acx_mpi90_libs" >&6; }
3977 > rm -f core conftest.err conftest.$ac_objext \
3978 >    conftest$ac_exeext conftest.$ac_ext
3979 > LIBS=$ac_check_lib_save_LIBS
3980 > fi
3981 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
3982 > $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
3983 > if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
3984 >  MPILIBS="-lmpich"
3985 > fi
3986  
3328 –
3987   fi
3988  
3989 < if test "$acx_mpi_cflags" = no -o "$acx_mpi_libs" = no; then
3989 > if test x != x"$MPILIBS"; then
3990 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
3991 > $as_echo_n "checking for mpi.h... " >&6; }
3992 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3993 > /* end confdefs.h.  */
3994 > #include <mpi.h>
3995 > int
3996 > main ()
3997 > {
3998  
3999 < acx_mpi_cflags=""
4000 < acx_mpi_libs=""
4001 < USE_MPI="no"
4002 <        { $as_echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
4003 < $as_echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
3999 >  ;
4000 >  return 0;
4001 > }
4002 > _ACEOF
4003 > if ac_fn_cxx_try_compile "$LINENO"; then :
4004 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4005 > $as_echo "yes" >&6; }
4006   else
4007 +  MPILIBS=""
4008 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4009 + $as_echo "no" >&6; }
4010 + fi
4011 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4012 + fi
4013  
4014 < MPI_CPPFLAGS=$acx_mpi_cflags
4014 > CXX="$ax_mpi_save_CXX"
4015  
3342 – MPI_LIBS=$acx_mpi_libs
4016  
3344 – if test "$acx_mpi90_libs" != no; then
3345 –  MPI90_LIBS=$acx_mpi90_libs
4017  
4018 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4019 + if test x = x"$MPILIBS"; then
4020 +        USE_MPI="no"
4021 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4022 + $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4023 +        :
4024 + else
4025 +        USE_MPI="yes"
4026 +        :
4027   fi
4028  
3349 – USE_MPI="yes"
3350 – fi
4029  
4030 + if test $USE_MPI != no; then :
4031  
4032 < fi
4032 > ac_ext=c
4033 > ac_cpp='$CPP $CPPFLAGS'
4034 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4035 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4036 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4037  
4038  
3356 – fi
4039  
4040  
4041  
4042 < # Checks for programs.
4043 < ac_ext=cpp
4044 < ac_cpp='$CXXCPP $CPPFLAGS'
4045 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4046 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4047 < 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
4042 >
4043 >        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4044 > do
4045 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
4046 > set dummy $ac_prog; ac_word=$2
4047 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4048   $as_echo_n "checking for $ac_word... " >&6; }
4049 < if test "${ac_cv_prog_CXX+set}" = set; then
4049 > if ${ac_cv_prog_MPICC+:} false; then :
4050    $as_echo_n "(cached) " >&6
4051   else
4052 <  if test -n "$CXX"; then
4053 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
4052 >  if test -n "$MPICC"; then
4053 >  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4054   else
4055   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4056   for as_dir in $PATH
4057   do
4058    IFS=$as_save_IFS
4059    test -z "$as_dir" && as_dir=.
4060 <  for ac_exec_ext in '' $ac_executable_extensions; do
4060 >    for ac_exec_ext in '' $ac_executable_extensions; do
4061    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4062 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
4063 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4062 >    ac_cv_prog_MPICC="$ac_prog"
4063 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4064      break 2
4065    fi
4066   done
4067 < done
4067 >  done
4068   IFS=$as_save_IFS
4069  
4070   fi
4071   fi
4072 < CXX=$ac_cv_prog_CXX
4073 < if test -n "$CXX"; then
4074 <  { $as_echo "$as_me:$LINENO: result: $CXX" >&5
4075 < $as_echo "$CXX" >&6; }
4072 > MPICC=$ac_cv_prog_MPICC
4073 > if test -n "$MPICC"; then
4074 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4075 > $as_echo "$MPICC" >&6; }
4076   else
4077 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4077 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4078   $as_echo "no" >&6; }
4079   fi
4080  
4081  
4082 <    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
4082 >  test -n "$MPICC" && break
4083   done
4084 < done
3440 < IFS=$as_save_IFS
4084 > test -n "$MPICC" || MPICC="$CC"
4085  
4086 +        ax_mpi_save_CC="$CC"
4087 +        CC="$MPICC"
4088 +
4089 +
4090 +
4091 + if test x = x"$MPILIBS"; then
4092 +        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4093 + if test "x$ac_cv_func_MPI_Init" = xyes; then :
4094 +  MPILIBS=" "
4095   fi
4096 +
4097   fi
4098 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
4099 < if test -n "$ac_ct_CXX"; then
4100 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
4101 < $as_echo "$ac_ct_CXX" >&6; }
4098 >
4099 > if test x = x"$MPILIBS"; then
4100 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4101 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4102 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
4103 >  $as_echo_n "(cached) " >&6
4104   else
4105 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4106 < $as_echo "no" >&6; }
4105 >  ac_check_lib_save_LIBS=$LIBS
4106 > LIBS="-lmpi  $LIBS"
4107 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4108 > /* end confdefs.h.  */
4109 >
4110 > /* Override any GCC internal prototype to avoid an error.
4111 >   Use char because int might match the return type of a GCC
4112 >   builtin and then its argument prototype would still apply.  */
4113 > #ifdef __cplusplus
4114 > extern "C"
4115 > #endif
4116 > char MPI_Init ();
4117 > int
4118 > main ()
4119 > {
4120 > return MPI_Init ();
4121 >  ;
4122 >  return 0;
4123 > }
4124 > _ACEOF
4125 > if ac_fn_c_try_link "$LINENO"; then :
4126 >  ac_cv_lib_mpi_MPI_Init=yes
4127 > else
4128 >  ac_cv_lib_mpi_MPI_Init=no
4129   fi
4130 + rm -f core conftest.err conftest.$ac_objext \
4131 +    conftest$ac_exeext conftest.$ac_ext
4132 + LIBS=$ac_check_lib_save_LIBS
4133 + fi
4134 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4135 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4136 + if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
4137 +  MPILIBS="-lmpi"
4138 + fi
4139  
4140 + fi
4141 + if test x = x"$MPILIBS"; then
4142 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4143 + $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4144 + if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
4145 +  $as_echo_n "(cached) " >&6
4146 + else
4147 +  ac_check_lib_save_LIBS=$LIBS
4148 + LIBS="-lmpich  $LIBS"
4149 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4150 + /* end confdefs.h.  */
4151  
4152 <  test -n "$ac_ct_CXX" && break
4153 < done
4154 <
4155 <  if test "x$ac_ct_CXX" = x; then
4156 <    CXX="g++"
4157 <  else
4158 <    case $cross_compiling:$ac_tool_warned in
4159 < yes:)
4160 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4161 < whose name does not start with the host triplet.  If you think this
4162 < configuration is useful to you, please write to autoconf@gnu.org." >&5
4163 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
4164 < whose name does not start with the host triplet.  If you think this
4165 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4166 < ac_tool_warned=yes ;;
4167 < esac
4168 <    CXX=$ac_ct_CXX
4169 <  fi
4152 > /* Override any GCC internal prototype to avoid an error.
4153 >   Use char because int might match the return type of a GCC
4154 >   builtin and then its argument prototype would still apply.  */
4155 > #ifdef __cplusplus
4156 > extern "C"
4157 > #endif
4158 > char MPI_Init ();
4159 > int
4160 > main ()
4161 > {
4162 > return MPI_Init ();
4163 >  ;
4164 >  return 0;
4165 > }
4166 > _ACEOF
4167 > if ac_fn_c_try_link "$LINENO"; then :
4168 >  ac_cv_lib_mpich_MPI_Init=yes
4169 > else
4170 >  ac_cv_lib_mpich_MPI_Init=no
4171   fi
4172 + rm -f core conftest.err conftest.$ac_objext \
4173 +    conftest$ac_exeext conftest.$ac_ext
4174 + LIBS=$ac_check_lib_save_LIBS
4175 + fi
4176 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4177 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4178 + if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
4179 +  MPILIBS="-lmpich"
4180 + fi
4181  
3474 –  fi
4182   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); }
4183  
4184 < cat >conftest.$ac_ext <<_ACEOF
4185 < /* confdefs.h.  */
4186 < _ACEOF
4187 < cat confdefs.h >>conftest.$ac_ext
3518 < cat >>conftest.$ac_ext <<_ACEOF
4184 > if test x != x"$MPILIBS"; then
4185 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4186 > $as_echo_n "checking for mpi.h... " >&6; }
4187 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4188   /* end confdefs.h.  */
4189 <
4189 > #include <mpi.h>
4190   int
4191   main ()
4192   {
# Line 3526 | Line 4195 | _ACEOF
4195    return 0;
4196   }
4197   _ACEOF
4198 < ac_clean_files_save=$ac_clean_files
4199 < ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
4200 < # Try to create an executable without -o first, disregard a.out.
4201 < # It will help us diagnose broken compilers, and finding out an intuition
4202 < # of exeext.
4203 < { $as_echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
4204 < $as_echo_n "checking for C++ compiler default output file name... " >&6; }
4205 < ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
4198 > if ac_fn_c_try_compile "$LINENO"; then :
4199 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4200 > $as_echo "yes" >&6; }
4201 > else
4202 >  MPILIBS=""
4203 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4204 > $as_echo "no" >&6; }
4205 > fi
4206 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4207 > fi
4208  
4209 < # The possible output files:
3539 < ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
4209 > CC="$ax_mpi_save_CC"
4210  
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
4211  
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=
4212  
4213 + # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4214 + if test x = x"$MPILIBS"; then
4215 +        USE_MPI="no"
4216 +       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4217 + $as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4218 +        :
4219   else
4220 <  ac_file=''
4220 >        USE_MPI="yes"
4221 >        :
4222   fi
4223  
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
4224  
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; }; }
4225   fi
4226 + if test $USE_MPI != no; then :
4227  
4228 < ac_exeext=$ac_cv_exeext
4228 >        CXX=$MPICXX
4229 >        CC=$MPICC
4230 >        LIBS="$MPILIBS $LIBS"
4231  
4232 < # Check that the compiler produces executables we can run.  If not, either
3614 < # the compiler is broken, or we cross compile.
3615 < { $as_echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
3616 < $as_echo_n "checking whether the C++ compiler works... " >&6; }
3617 < # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3618 < # If not cross compiling, check that we can run a simple program.
3619 < if test "$cross_compiling" != yes; then
3620 <  if { ac_try='./$ac_file'
3621 <  { (case "(($ac_try" in
3622 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3623 <  *) ac_try_echo=$ac_try;;
3624 < esac
3625 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3626 < $as_echo "$ac_try_echo") >&5
3627 <  (eval "$ac_try") 2>&5
3628 <  ac_status=$?
3629 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3630 <  (exit $ac_status); }; }; then
3631 <    cross_compiling=no
3632 <  else
3633 <    if test "$cross_compiling" = maybe; then
3634 <        cross_compiling=yes
3635 <    else
3636 <        { { $as_echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
3637 < If you meant to cross compile, use \`--host'.
3638 < See \`config.log' for more details." >&5
3639 < $as_echo "$as_me: error: cannot run C++ compiled programs.
3640 < If you meant to cross compile, use \`--host'.
3641 < See \`config.log' for more details." >&2;}
3642 <   { (exit 1); exit 1; }; }
3643 <    fi
3644 <  fi
3645 < fi
3646 < { $as_echo "$as_me:$LINENO: result: yes" >&5
3647 < $as_echo "yes" >&6; }
4232 > else
4233  
4234 < rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
4235 < ac_clean_files=$ac_clean_files_save
4236 < # Check that the compiler produces executables we can run.  If not, either
3652 < # the compiler is broken, or we cross compile.
3653 < { $as_echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3654 < $as_echo_n "checking whether we are cross compiling... " >&6; }
3655 < { $as_echo "$as_me:$LINENO: result: $cross_compiling" >&5
3656 < $as_echo "$cross_compiling" >&6; }
4234 >        CXX=$save_CXX
4235 >        CC=$save_CC
4236 >        LIBS=$save_LIBS
4237  
4238 < { $as_echo "$as_me:$LINENO: checking for suffix of executables" >&5
3659 < $as_echo_n "checking for suffix of executables... " >&6; }
3660 < if { (ac_try="$ac_link"
3661 < case "(($ac_try" in
3662 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3663 <  *) ac_try_echo=$ac_try;;
3664 < esac
3665 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3666 < $as_echo "$ac_try_echo") >&5
3667 <  (eval "$ac_link") 2>&5
3668 <  ac_status=$?
3669 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3670 <  (exit $ac_status); }; then
3671 <  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3672 < # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3673 < # work properly (i.e., refer to `conftest.exe'), while it won't with
3674 < # `rm'.
3675 < for ac_file in conftest.exe conftest conftest.*; do
3676 <  test -f "$ac_file" || continue
3677 <  case $ac_file in
3678 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3679 <    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3680 <          break;;
3681 <    * ) break;;
3682 <  esac
3683 < done
3684 < else
3685 <  { { $as_echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3686 < See \`config.log' for more details." >&5
3687 < $as_echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3688 < See \`config.log' for more details." >&2;}
3689 <   { (exit 1); exit 1; }; }
4238 >
4239   fi
4240  
3692 – rm -f conftest$ac_cv_exeext
3693 – { $as_echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3694 – $as_echo "$ac_cv_exeext" >&6; }
4241  
4242 < rm -f conftest.$ac_ext
4243 < EXEEXT=$ac_cv_exeext
4244 < ac_exeext=$EXEEXT
4245 < { $as_echo "$as_me:$LINENO: checking for suffix of object files" >&5
4246 < $as_echo_n "checking for suffix of object files... " >&6; }
4247 < if test "${ac_cv_objext+set}" = set; then
4242 > # Checks for programs.
4243 > ac_ext=c
4244 > ac_cpp='$CPP $CPPFLAGS'
4245 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4246 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4247 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4248 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
4249 > $as_echo_n "checking how to run the C preprocessor... " >&6; }
4250 > # On Suns, sometimes $CPP names a directory.
4251 > if test -n "$CPP" && test -d "$CPP"; then
4252 >  CPP=
4253 > fi
4254 > if test -z "$CPP"; then
4255 >  if ${ac_cv_prog_CPP+:} false; then :
4256    $as_echo_n "(cached) " >&6
4257   else
4258 <  cat >conftest.$ac_ext <<_ACEOF
4259 < /* confdefs.h.  */
4260 < _ACEOF
4261 < cat confdefs.h >>conftest.$ac_ext
4262 < cat >>conftest.$ac_ext <<_ACEOF
4258 >      # Double quotes because CPP needs to be expanded
4259 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4260 >    do
4261 >      ac_preproc_ok=false
4262 > for ac_c_preproc_warn_flag in '' yes
4263 > do
4264 >  # Use a header file that comes with gcc, so configuring glibc
4265 >  # with a fresh cross-compiler works.
4266 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4267 >  # <limits.h> exists even on freestanding compilers.
4268 >  # On the NeXT, cc -E runs the code through the compiler's parser,
4269 >  # not just through cpp. "Syntax error" is here to catch this case.
4270 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4271   /* end confdefs.h.  */
4272 + #ifdef __STDC__
4273 + # include <limits.h>
4274 + #else
4275 + # include <assert.h>
4276 + #endif
4277 +                     Syntax error
4278 + _ACEOF
4279 + if ac_fn_c_try_cpp "$LINENO"; then :
4280  
4281 < int
4282 < main ()
4283 < {
4281 > else
4282 >  # Broken: fails on valid input.
4283 > continue
4284 > fi
4285 > rm -f conftest.err conftest.i conftest.$ac_ext
4286  
4287 <  ;
4288 <  return 0;
4289 < }
4287 >  # OK, works on sane cases.  Now check whether nonexistent headers
4288 >  # can be detected and how.
4289 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4290 > /* end confdefs.h.  */
4291 > #include <ac_nonexistent.h>
4292   _ACEOF
4293 < rm -f conftest.o conftest.obj
4294 < if { (ac_try="$ac_compile"
4295 < case "(($ac_try" in
3722 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3723 <  *) ac_try_echo=$ac_try;;
3724 < esac
3725 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3726 < $as_echo "$ac_try_echo") >&5
3727 <  (eval "$ac_compile") 2>&5
3728 <  ac_status=$?
3729 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3730 <  (exit $ac_status); }; then
3731 <  for ac_file in conftest.o conftest.obj conftest.*; do
3732 <  test -f "$ac_file" || continue;
3733 <  case $ac_file in
3734 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3735 <    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3736 <       break;;
3737 <  esac
3738 < done
4293 > if ac_fn_c_try_cpp "$LINENO"; then :
4294 >  # Broken: success on invalid input.
4295 > continue
4296   else
4297 <  $as_echo "$as_me: failed program was:" >&5
4298 < sed 's/^/| /' conftest.$ac_ext >&5
4297 >  # Passes both tests.
4298 > ac_preproc_ok=:
4299 > break
4300 > fi
4301 > rm -f conftest.err conftest.i conftest.$ac_ext
4302  
4303 < { { $as_echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
4304 < See \`config.log' for more details." >&5
4305 < $as_echo "$as_me: error: cannot compute suffix of object files: cannot compile
4306 < See \`config.log' for more details." >&2;}
4307 <   { (exit 1); exit 1; }; }
4303 > done
4304 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4305 > rm -f conftest.i conftest.err conftest.$ac_ext
4306 > if $ac_preproc_ok; then :
4307 >  break
4308   fi
4309  
4310 < rm -f conftest.$ac_cv_objext conftest.$ac_ext
4310 >    done
4311 >    ac_cv_prog_CPP=$CPP
4312 >
4313   fi
4314 < { $as_echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3753 < $as_echo "$ac_cv_objext" >&6; }
3754 < OBJEXT=$ac_cv_objext
3755 < ac_objext=$OBJEXT
3756 < { $as_echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3757 < $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3758 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3759 <  $as_echo_n "(cached) " >&6
4314 >  CPP=$ac_cv_prog_CPP
4315   else
4316 <  cat >conftest.$ac_ext <<_ACEOF
4317 < /* confdefs.h.  */
4318 < _ACEOF
4319 < cat confdefs.h >>conftest.$ac_ext
4320 < cat >>conftest.$ac_ext <<_ACEOF
4316 >  ac_cv_prog_CPP=$CPP
4317 > fi
4318 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
4319 > $as_echo "$CPP" >&6; }
4320 > ac_preproc_ok=false
4321 > for ac_c_preproc_warn_flag in '' yes
4322 > do
4323 >  # Use a header file that comes with gcc, so configuring glibc
4324 >  # with a fresh cross-compiler works.
4325 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4326 >  # <limits.h> exists even on freestanding compilers.
4327 >  # On the NeXT, cc -E runs the code through the compiler's parser,
4328 >  # not just through cpp. "Syntax error" is here to catch this case.
4329 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4330   /* end confdefs.h.  */
4331 <
4332 < int
4333 < main ()
4334 < {
3771 < #ifndef __GNUC__
3772 <       choke me
4331 > #ifdef __STDC__
4332 > # include <limits.h>
4333 > #else
4334 > # include <assert.h>
4335   #endif
4336 <
3775 <  ;
3776 <  return 0;
3777 < }
4336 >                     Syntax error
4337   _ACEOF
4338 < rm -f conftest.$ac_objext
4339 < if { (ac_try="$ac_compile"
3781 < case "(($ac_try" in
3782 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3783 <  *) ac_try_echo=$ac_try;;
3784 < esac
3785 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3786 < $as_echo "$ac_try_echo") >&5
3787 <  (eval "$ac_compile") 2>conftest.er1
3788 <  ac_status=$?
3789 <  grep -v '^ *+' conftest.er1 >conftest.err
3790 <  rm -f conftest.er1
3791 <  cat conftest.err >&5
3792 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3793 <  (exit $ac_status); } && {
3794 <         test -z "$ac_cxx_werror_flag" ||
3795 <         test ! -s conftest.err
3796 <       } && test -s conftest.$ac_objext; then
3797 <  ac_compiler_gnu=yes
4338 > if ac_fn_c_try_cpp "$LINENO"; then :
4339 >
4340   else
4341 <  $as_echo "$as_me: failed program was:" >&5
4342 < sed 's/^/| /' conftest.$ac_ext >&5
4341 >  # Broken: fails on valid input.
4342 > continue
4343 > fi
4344 > rm -f conftest.err conftest.i conftest.$ac_ext
4345  
4346 <        ac_compiler_gnu=no
4346 >  # OK, works on sane cases.  Now check whether nonexistent headers
4347 >  # can be detected and how.
4348 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4349 > /* end confdefs.h.  */
4350 > #include <ac_nonexistent.h>
4351 > _ACEOF
4352 > if ac_fn_c_try_cpp "$LINENO"; then :
4353 >  # Broken: success on invalid input.
4354 > continue
4355 > else
4356 >  # Passes both tests.
4357 > ac_preproc_ok=:
4358 > break
4359   fi
4360 + rm -f conftest.err conftest.i conftest.$ac_ext
4361  
4362 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4363 < ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4362 > done
4363 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4364 > rm -f conftest.i conftest.err conftest.$ac_ext
4365 > if $ac_preproc_ok; then :
4366  
3808 – fi
3809 – { $as_echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3810 – $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3811 – if test $ac_compiler_gnu = yes; then
3812 –  GXX=yes
4367   else
4368 <  GXX=
4368 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4369 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4370 > as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
4371 > See \`config.log' for more details" "$LINENO" 5; }
4372   fi
4373 < ac_test_CXXFLAGS=${CXXFLAGS+set}
4374 < ac_save_CXXFLAGS=$CXXFLAGS
4375 < { $as_echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4376 < $as_echo_n "checking whether $CXX accepts -g... " >&6; }
4377 < if test "${ac_cv_prog_cxx_g+set}" = set; then
4373 >
4374 > ac_ext=c
4375 > ac_cpp='$CPP $CPPFLAGS'
4376 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4377 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4378 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4379 >
4380 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
4381 > $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
4382 > if ${ac_cv_path_GREP+:} false; then :
4383    $as_echo_n "(cached) " >&6
4384   else
4385 <  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
4386 <   ac_cxx_werror_flag=yes
4387 <   ac_cv_prog_cxx_g=no
4388 <   CXXFLAGS="-g"
4389 <   cat >conftest.$ac_ext <<_ACEOF
4390 < /* confdefs.h.  */
4391 < _ACEOF
4392 < cat confdefs.h >>conftest.$ac_ext
4393 < cat >>conftest.$ac_ext <<_ACEOF
4394 < /* end confdefs.h.  */
4395 <
4396 < int
4397 < main ()
4398 < {
4399 <
4400 <  ;
4401 <  return 0;
4402 < }
4403 < _ACEOF
4404 < rm -f conftest.$ac_objext
4405 < if { (ac_try="$ac_compile"
4406 < case "(($ac_try" in
4407 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4408 <  *) ac_try_echo=$ac_try;;
4385 >  if test -z "$GREP"; then
4386 >  ac_path_GREP_found=false
4387 >  # Loop through the user's path and test for each of PROGNAME-LIST
4388 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4389 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4390 > do
4391 >  IFS=$as_save_IFS
4392 >  test -z "$as_dir" && as_dir=.
4393 >    for ac_prog in grep ggrep; do
4394 >    for ac_exec_ext in '' $ac_executable_extensions; do
4395 >      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4396 >      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4397 > # Check for GNU ac_path_GREP and select it if it is found.
4398 >  # Check for GNU $ac_path_GREP
4399 > case `"$ac_path_GREP" --version 2>&1` in
4400 > *GNU*)
4401 >  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4402 > *)
4403 >  ac_count=0
4404 >  $as_echo_n 0123456789 >"conftest.in"
4405 >  while :
4406 >  do
4407 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
4408 >    mv "conftest.tmp" "conftest.in"
4409 >    cp "conftest.in" "conftest.nl"
4410 >    $as_echo 'GREP' >> "conftest.nl"
4411 >    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4412 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4413 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4414 >    if test $ac_count -gt ${ac_path_GREP_max-0}; then
4415 >      # Best one so far, save it but keep looking for a better one
4416 >      ac_cv_path_GREP="$ac_path_GREP"
4417 >      ac_path_GREP_max=$ac_count
4418 >    fi
4419 >    # 10*(2^10) chars as input seems more than enough
4420 >    test $ac_count -gt 10 && break
4421 >  done
4422 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
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); } && {
3857 <         test -z "$ac_cxx_werror_flag" ||
3858 <         test ! -s conftest.err
3859 <       } && test -s conftest.$ac_objext; then
3860 <  ac_cv_prog_cxx_g=yes
4424 >
4425 >      $ac_path_GREP_found && break 3
4426 >    done
4427 >  done
4428 >  done
4429 > IFS=$as_save_IFS
4430 >  if test -z "$ac_cv_path_GREP"; then
4431 >    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4432 >  fi
4433   else
4434 <  $as_echo "$as_me: failed program was:" >&5
4435 < sed 's/^/| /' conftest.$ac_ext >&5
4434 >  ac_cv_path_GREP=$GREP
4435 > fi
4436  
4437 <        CXXFLAGS=""
4438 <      cat >conftest.$ac_ext <<_ACEOF
4439 < /* confdefs.h.  */
4440 < _ACEOF
3869 < cat confdefs.h >>conftest.$ac_ext
3870 < cat >>conftest.$ac_ext <<_ACEOF
3871 < /* end confdefs.h.  */
4437 > fi
4438 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
4439 > $as_echo "$ac_cv_path_GREP" >&6; }
4440 > GREP="$ac_cv_path_GREP"
4441  
3873 – int
3874 – main ()
3875 – {
4442  
4443 <  ;
4444 <  return 0;
4445 < }
4446 < _ACEOF
4447 < rm -f conftest.$ac_objext
4448 < if { (ac_try="$ac_compile"
4449 < case "(($ac_try" in
4450 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4451 <  *) ac_try_echo=$ac_try;;
4443 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
4444 > $as_echo_n "checking for egrep... " >&6; }
4445 > if ${ac_cv_path_EGREP+:} false; then :
4446 >  $as_echo_n "(cached) " >&6
4447 > else
4448 >  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
4449 >   then ac_cv_path_EGREP="$GREP -E"
4450 >   else
4451 >     if test -z "$EGREP"; then
4452 >  ac_path_EGREP_found=false
4453 >  # Loop through the user's path and test for each of PROGNAME-LIST
4454 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4455 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4456 > do
4457 >  IFS=$as_save_IFS
4458 >  test -z "$as_dir" && as_dir=.
4459 >    for ac_prog in egrep; do
4460 >    for ac_exec_ext in '' $ac_executable_extensions; do
4461 >      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4462 >      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4463 > # Check for GNU ac_path_EGREP and select it if it is found.
4464 >  # Check for GNU $ac_path_EGREP
4465 > case `"$ac_path_EGREP" --version 2>&1` in
4466 > *GNU*)
4467 >  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
4468 > *)
4469 >  ac_count=0
4470 >  $as_echo_n 0123456789 >"conftest.in"
4471 >  while :
4472 >  do
4473 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
4474 >    mv "conftest.tmp" "conftest.in"
4475 >    cp "conftest.in" "conftest.nl"
4476 >    $as_echo 'EGREP' >> "conftest.nl"
4477 >    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4478 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4479 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4480 >    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
4481 >      # Best one so far, save it but keep looking for a better one
4482 >      ac_cv_path_EGREP="$ac_path_EGREP"
4483 >      ac_path_EGREP_max=$ac_count
4484 >    fi
4485 >    # 10*(2^10) chars as input seems more than enough
4486 >    test $ac_count -gt 10 && break
4487 >  done
4488 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4489   esac
4490 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4491 < $as_echo "$ac_try_echo") >&5
4492 <  (eval "$ac_compile") 2>conftest.er1
4493 <  ac_status=$?
4494 <  grep -v '^ *+' conftest.er1 >conftest.err
4495 <  rm -f conftest.er1
4496 <  cat conftest.err >&5
4497 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
4498 <  (exit $ac_status); } && {
3896 <         test -z "$ac_cxx_werror_flag" ||
3897 <         test ! -s conftest.err
3898 <       } && test -s conftest.$ac_objext; then
3899 <  :
4490 >
4491 >      $ac_path_EGREP_found && break 3
4492 >    done
4493 >  done
4494 >  done
4495 > IFS=$as_save_IFS
4496 >  if test -z "$ac_cv_path_EGREP"; then
4497 >    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4498 >  fi
4499   else
4500 <  $as_echo "$as_me: failed program was:" >&5
4501 < sed 's/^/| /' conftest.$ac_ext >&5
4500 >  ac_cv_path_EGREP=$EGREP
4501 > fi
4502  
4503 <        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
4504 <         CXXFLAGS="-g"
4505 <         cat >conftest.$ac_ext <<_ACEOF
4506 < /* confdefs.h.  */
4507 < _ACEOF
3909 < cat confdefs.h >>conftest.$ac_ext
3910 < cat >>conftest.$ac_ext <<_ACEOF
3911 < /* end confdefs.h.  */
4503 >   fi
4504 > fi
4505 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
4506 > $as_echo "$ac_cv_path_EGREP" >&6; }
4507 > EGREP="$ac_cv_path_EGREP"
4508  
3913 – int
3914 – main ()
3915 – {
4509  
4510 <  ;
4511 <  return 0;
4512 < }
4513 < _ACEOF
4514 < rm -f conftest.$ac_objext
4515 < if { (ac_try="$ac_compile"
3923 < case "(($ac_try" in
3924 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3925 <  *) ac_try_echo=$ac_try;;
3926 < esac
3927 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3928 < $as_echo "$ac_try_echo") >&5
3929 <  (eval "$ac_compile") 2>conftest.er1
3930 <  ac_status=$?
3931 <  grep -v '^ *+' conftest.er1 >conftest.err
3932 <  rm -f conftest.er1
3933 <  cat conftest.err >&5
3934 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3935 <  (exit $ac_status); } && {
3936 <         test -z "$ac_cxx_werror_flag" ||
3937 <         test ! -s conftest.err
3938 <       } && test -s conftest.$ac_objext; then
3939 <  ac_cv_prog_cxx_g=yes
4510 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
4511 > $as_echo_n "checking whether ln -s works... " >&6; }
4512 > LN_S=$as_ln_s
4513 > if test "$LN_S" = "ln -s"; then
4514 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4515 > $as_echo "yes" >&6; }
4516   else
4517 <  $as_echo "$as_me: failed program was:" >&5
4518 < sed 's/^/| /' conftest.$ac_ext >&5
3943 <
3944 <
4517 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
4518 > $as_echo "no, using $LN_S" >&6; }
4519   fi
4520  
4521 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4521 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4522 > $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
4523 > set x ${MAKE-make}
4524 > ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
4525 > if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
4526 >  $as_echo_n "(cached) " >&6
4527 > else
4528 >  cat >conftest.make <<\_ACEOF
4529 > SHELL = /bin/sh
4530 > all:
4531 >        @echo '@@@%%%=$(MAKE)=@@@%%%'
4532 > _ACEOF
4533 > # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
4534 > case `${MAKE-make} -f conftest.make 2>/dev/null` in
4535 >  *@@@%%%=?*=@@@%%%*)
4536 >    eval ac_cv_prog_make_${ac_make}_set=yes;;
4537 >  *)
4538 >    eval ac_cv_prog_make_${ac_make}_set=no;;
4539 > esac
4540 > rm -f conftest.make
4541   fi
4542 <
4543 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4544 < fi
4545 <
3953 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3954 <   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3955 < fi
3956 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3957 < $as_echo "$ac_cv_prog_cxx_g" >&6; }
3958 < if test "$ac_test_CXXFLAGS" = set; then
3959 <  CXXFLAGS=$ac_save_CXXFLAGS
3960 < elif test $ac_cv_prog_cxx_g = yes; then
3961 <  if test "$GXX" = yes; then
3962 <    CXXFLAGS="-g -O2"
3963 <  else
3964 <    CXXFLAGS="-g"
3965 <  fi
4542 > if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
4543 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4544 > $as_echo "yes" >&6; }
4545 >  SET_MAKE=
4546   else
4547 <  if test "$GXX" = yes; then
4548 <    CXXFLAGS="-O2"
4549 <  else
3970 <    CXXFLAGS=
3971 <  fi
4547 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4548 > $as_echo "no" >&6; }
4549 >  SET_MAKE="MAKE=${MAKE-make}"
4550   fi
3973 – ac_ext=c
3974 – ac_cpp='$CPP $CPPFLAGS'
3975 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3976 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3977 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
4551  
3979 – ac_ext=c
3980 – ac_cpp='$CPP $CPPFLAGS'
3981 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3982 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3983 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
4552   if test -n "$ac_tool_prefix"; then
4553 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4554 <  do
4555 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3988 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3989 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4553 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4554 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4555 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4556   $as_echo_n "checking for $ac_word... " >&6; }
4557 < if test "${ac_cv_prog_CC+set}" = set; then
4557 > if ${ac_cv_prog_RANLIB+:} false; then :
4558    $as_echo_n "(cached) " >&6
4559   else
4560 <  if test -n "$CC"; then
4561 <  ac_cv_prog_CC="$CC" # Let the user override the test.
4560 >  if test -n "$RANLIB"; then
4561 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4562   else
4563   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4564   for as_dir in $PATH
4565   do
4566    IFS=$as_save_IFS
4567    test -z "$as_dir" && as_dir=.
4568 <  for ac_exec_ext in '' $ac_executable_extensions; do
4568 >    for ac_exec_ext in '' $ac_executable_extensions; do
4569    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4570 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4571 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4570 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4571 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4572      break 2
4573    fi
4574   done
4575 < done
4575 >  done
4576   IFS=$as_save_IFS
4577  
4578   fi
4579   fi
4580 < CC=$ac_cv_prog_CC
4581 < if test -n "$CC"; then
4582 <  { $as_echo "$as_me:$LINENO: result: $CC" >&5
4583 < $as_echo "$CC" >&6; }
4580 > RANLIB=$ac_cv_prog_RANLIB
4581 > if test -n "$RANLIB"; then
4582 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
4583 > $as_echo "$RANLIB" >&6; }
4584   else
4585 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4585 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4586   $as_echo "no" >&6; }
4587   fi
4588  
4589  
4024 –    test -n "$CC" && break
4025 –  done
4590   fi
4591 < if test -z "$CC"; then
4592 <  ac_ct_CC=$CC
4593 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
4594 < do
4595 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4032 < set dummy $ac_prog; ac_word=$2
4033 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4591 > if test -z "$ac_cv_prog_RANLIB"; then
4592 >  ac_ct_RANLIB=$RANLIB
4593 >  # Extract the first word of "ranlib", so it can be a program name with args.
4594 > set dummy ranlib; ac_word=$2
4595 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4596   $as_echo_n "checking for $ac_word... " >&6; }
4597 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4597 > if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
4598    $as_echo_n "(cached) " >&6
4599   else
4600 <  if test -n "$ac_ct_CC"; then
4601 <  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4600 >  if test -n "$ac_ct_RANLIB"; then
4601 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4602   else
4603   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4604   for as_dir in $PATH
4605   do
4606    IFS=$as_save_IFS
4607    test -z "$as_dir" && as_dir=.
4608 <  for ac_exec_ext in '' $ac_executable_extensions; do
4608 >    for ac_exec_ext in '' $ac_executable_extensions; do
4609    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4610 <    ac_cv_prog_ac_ct_CC="$ac_prog"
4611 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4610 >    ac_cv_prog_ac_ct_RANLIB="ranlib"
4611 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4612      break 2
4613    fi
4614   done
4615 < done
4615 >  done
4616   IFS=$as_save_IFS
4617  
4618   fi
4619   fi
4620 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
4621 < if test -n "$ac_ct_CC"; then
4622 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4623 < $as_echo "$ac_ct_CC" >&6; }
4620 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4621 > if test -n "$ac_ct_RANLIB"; then
4622 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
4623 > $as_echo "$ac_ct_RANLIB" >&6; }
4624   else
4625 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4625 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4626   $as_echo "no" >&6; }
4627   fi
4628  
4629 <
4630 <  test -n "$ac_ct_CC" && break
4069 < done
4070 <
4071 <  if test "x$ac_ct_CC" = x; then
4072 <    CC=""
4629 >  if test "x$ac_ct_RANLIB" = x; then
4630 >    RANLIB=":"
4631    else
4632      case $cross_compiling:$ac_tool_warned in
4633   yes:)
4634 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4635 < 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;}
4634 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4635 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4636   ac_tool_warned=yes ;;
4637   esac
4638 <    CC=$ac_ct_CC
4638 >    RANLIB=$ac_ct_RANLIB
4639    fi
4640 + else
4641 +  RANLIB="$ac_cv_prog_RANLIB"
4642   fi
4643  
4644  
4645 < test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
4646 < See \`config.log' for more details." >&5
4647 < $as_echo "$as_me: error: no acceptable C compiler found in \$PATH
4648 < See \`config.log' for more details." >&2;}
4649 <   { (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
4645 >   # Extract the first word of "perl", so it can be a program name with args.
4646 > set dummy perl; ac_word=$2
4647 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4648 > $as_echo_n "checking for $ac_word... " >&6; }
4649 > if ${ac_cv_path_PERLINTERP+:} false; then :
4650    $as_echo_n "(cached) " >&6
4651   else
4652 <  cat >conftest.$ac_ext <<_ACEOF
4653 < /* confdefs.h.  */
4654 < _ACEOF
4655 < cat confdefs.h >>conftest.$ac_ext
4656 < cat >>conftest.$ac_ext <<_ACEOF
4657 < /* end confdefs.h.  */
4652 >  case $PERLINTERP in
4653 >  [\\/]* | ?:[\\/]*)
4654 >  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
4655 >  ;;
4656 >  *)
4657 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4658 > for as_dir in $PATH
4659 > do
4660 >  IFS=$as_save_IFS
4661 >  test -z "$as_dir" && as_dir=.
4662 >    for ac_exec_ext in '' $ac_executable_extensions; do
4663 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4664 >    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
4665 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4666 >    break 2
4667 >  fi
4668 > done
4669 >  done
4670 > IFS=$as_save_IFS
4671  
4672 < int
4673 < 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;;
4672 >  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
4673 >  ;;
4674   esac
4675 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
4676 < $as_echo "$ac_try_echo") >&5
4677 <  (eval "$ac_compile") 2>conftest.er1
4678 <  ac_status=$?
4679 <  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
4675 > fi
4676 > PERLINTERP=$ac_cv_path_PERLINTERP
4677 > if test -n "$PERLINTERP"; then
4678 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERLINTERP" >&5
4679 > $as_echo "$PERLINTERP" >&6; }
4680   else
4681 <  $as_echo "$as_me: failed program was:" >&5
4682 < sed 's/^/| /' conftest.$ac_ext >&5
4178 <
4179 <        ac_compiler_gnu=no
4681 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4682 > $as_echo "no" >&6; }
4683   fi
4684  
4182 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4183 – ac_cv_c_compiler_gnu=$ac_compiler_gnu
4685  
4686 < fi
4687 < { $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.  */
4686 >   ac_cv_path_perlinterp="$PERLINTERP"
4687 >   _sHpB='#!'
4688  
4211 – int
4212 – main ()
4213 – {
4689  
4690 <  ;
4691 <  return 0;
4692 < }
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
4690 > # Check whether --with-perl-shebang was given.
4691 > if test "${with_perl_shebang+set}" = set; then :
4692 >  withval=$with_perl_shebang; opt_perl_shebang="$withval"
4693   else
4694 <  $as_echo "$as_me: failed program was:" >&5
4695 < sed 's/^/| /' conftest.$ac_ext >&5
4694 >                opt_perl_shebang="not_set"
4695 > fi
4696  
4697 <        CFLAGS=""
4698 <      cat >conftest.$ac_ext <<_ACEOF
4699 < /* confdefs.h.  */
4700 < _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 <  :
4697 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether explicit instead of detected sharpbang is to be used" >&5
4698 > $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
4699 > if ${ax_cv_opt_perl_shebang+:} false; then :
4700 >  $as_echo_n "(cached) " >&6
4701   else
4702 <  $as_echo "$as_me: failed program was:" >&5
4703 < sed 's/^/| /' conftest.$ac_ext >&5
4702 >   case "$opt_perl_shebang" in
4703 >                      not_set  ) ax_cv_opt_perl_shebang=''
4704 >                               ;;
4705 >                         *     )
4706 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
4707 >                    esac
4708  
4709 <        ac_c_werror_flag=$ac_save_c_werror_flag
4710 <         CFLAGS="-g"
4711 <         cat >conftest.$ac_ext <<_ACEOF
4712 < /* confdefs.h.  */
4713 < _ACEOF
4714 < cat confdefs.h >>conftest.$ac_ext
4715 < cat >>conftest.$ac_ext <<_ACEOF
4716 < /* end confdefs.h.  */
4709 > fi
4710 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_opt_perl_shebang" >&5
4711 > $as_echo "$ax_cv_opt_perl_shebang" >&6; }
4712 >   if test "A$ax_cv_opt_perl_shebang" != "A"
4713 >     then
4714 >       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
4715 >       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4716 >              { $as_echo "$as_me:${as_lineno-$LINENO}: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
4717 > $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
4718  
4719 < int
4720 < main ()
4721 < {
4722 <
4723 <  ;
4724 <  return 0;
4725 < }
4726 < _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
4719 > # Automatic detection of sharpbang formula starts here
4720 >     else
4721 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
4722 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
4723 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel sharpbang invocation to start perl" >&5
4724 > $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
4725 > if ${ac_cv_sys_kernshrpbang_perl+:} false; then :
4726 >  $as_echo_n "(cached) " >&6
4727   else
4728 <  $as_echo "$as_me: failed program was:" >&5
4729 < sed 's/^/| /' conftest.$ac_ext >&5
4728 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
4729 >        if test "x$_somian_kspb_perl" == x
4730 >          then _somian_ksbp_warn_empty='durnit'
4731 >          else
4732 >          case "A$_somian_kspb_perl" in
4733 >                 A#!*perl* )
4734 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
4735 >                        ;;
4736 >                     A*    )  _somian_ksbp_warn_defau='trouble'
4737 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
4738 >          esac
4739 >        fi
4740  
4321 –
4741   fi
4742 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_kernshrpbang_perl" >&5
4743 + $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
4744 + # The above prints Checking ... result message to user.
4745 +   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4746  
4747 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4748 < fi
4749 <
4750 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4751 < fi
4752 <
4753 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4754 <   ac_c_werror_flag=$ac_save_c_werror_flag
4755 < fi
4756 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
4757 < $as_echo "$ac_cv_prog_cc_g" >&6; }
4758 < if test "$ac_test_CFLAGS" = set; then
4759 <  CFLAGS=$ac_save_CFLAGS
4760 < elif test $ac_cv_prog_cc_g = yes; then
4761 <  if test "$GCC" = yes; then
4339 <    CFLAGS="-g -O2"
4340 <  else
4341 <    CFLAGS="-g"
4747 >    if test A${_somian_ksbp_warn_empty+set} == Aset
4748 >      then   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
4749 > $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
4750 >    fi
4751 > # Inform user after printing result value
4752 >    if test A${_somian_ksbp_warn_defau+set} == Aset
4753 >      then { $as_echo "$as_me:${as_lineno-$LINENO}: Maybe Not good -" >&5
4754 > $as_echo "$as_me: Maybe Not good -" >&6;}
4755 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
4756 > $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
4757 >      else { $as_echo "$as_me:${as_lineno-$LINENO}: OK Good result - " >&5
4758 > $as_echo "$as_me: OK Good result - " >&6;}
4759 >           { $as_echo "$as_me:${as_lineno-$LINENO}: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
4760 > $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
4761 >    fi
4762    fi
4763 +
4764 + # Find a good install program.  We prefer a C program (faster),
4765 + # so one script is as good as another.  But avoid the broken or
4766 + # incompatible versions:
4767 + # SysV /etc/install, /usr/sbin/install
4768 + # SunOS /usr/etc/install
4769 + # IRIX /sbin/install
4770 + # AIX /bin/install
4771 + # AmigaOS /C/install, which installs bootblocks on floppy discs
4772 + # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
4773 + # AFS /usr/afsws/bin/install, which mishandles nonexistent args
4774 + # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
4775 + # OS/2's system install, which has a completely different semantic
4776 + # ./install, which can be erroneously created by make from ./install.sh.
4777 + # Reject install programs that cannot install multiple files.
4778 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
4779 + $as_echo_n "checking for a BSD-compatible install... " >&6; }
4780 + if test -z "$INSTALL"; then
4781 + if ${ac_cv_path_install+:} false; then :
4782 +  $as_echo_n "(cached) " >&6
4783   else
4784 <  if test "$GCC" = yes; then
4785 <    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__"
4784 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4785 > for as_dir in $PATH
4786   do
4787 <  CC="$ac_save_CC $ac_arg"
4788 <  rm -f conftest.$ac_objext
4789 < if { (ac_try="$ac_compile"
4790 < case "(($ac_try" in
4791 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4792 <  *) ac_try_echo=$ac_try;;
4787 >  IFS=$as_save_IFS
4788 >  test -z "$as_dir" && as_dir=.
4789 >    # Account for people who put trailing slashes in PATH elements.
4790 > case $as_dir/ in #((
4791 >  ./ | .// | /[cC]/* | \
4792 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
4793 >  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
4794 >  /usr/ucb/* ) ;;
4795 >  *)
4796 >    # OSF1 and SCO ODT 3.0 have their own names for install.
4797 >    # Don't use installbsd from OSF since it installs stuff as root
4798 >    # by default.
4799 >    for ac_prog in ginstall scoinst install; do
4800 >      for ac_exec_ext in '' $ac_executable_extensions; do
4801 >        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
4802 >          if test $ac_prog = install &&
4803 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4804 >            # AIX install.  It has an incompatible calling convention.
4805 >            :
4806 >          elif test $ac_prog = install &&
4807 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4808 >            # program-specific install script used by HP pwplus--don't use.
4809 >            :
4810 >          else
4811 >            rm -rf conftest.one conftest.two conftest.dir
4812 >            echo one > conftest.one
4813 >            echo two > conftest.two
4814 >            mkdir conftest.dir
4815 >            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
4816 >              test -s conftest.one && test -s conftest.two &&
4817 >              test -s conftest.dir/conftest.one &&
4818 >              test -s conftest.dir/conftest.two
4819 >            then
4820 >              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
4821 >              break 3
4822 >            fi
4823 >          fi
4824 >        fi
4825 >      done
4826 >    done
4827 >    ;;
4828   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
4829  
4830 +  done
4831 + IFS=$as_save_IFS
4832  
4833 < fi
4833 > rm -rf conftest.one conftest.two conftest.dir
4834  
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 –
4835   fi
4836 < # AC_CACHE_VAL
4837 < case "x$ac_cv_prog_cc_c89" in
4838 <  x)
4839 <    { $as_echo "$as_me:$LINENO: result: none needed" >&5
4840 < $as_echo "none needed" >&6; } ;;
4841 <  xno)
4842 <    { $as_echo "$as_me:$LINENO: result: unsupported" >&5
4843 < $as_echo "unsupported" >&6; } ;;
4844 <  *)
4845 <    CC="$CC $ac_cv_prog_cc_c89"
4846 <    { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
4847 < $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
4463 < esac
4836 >  if test "${ac_cv_path_install+set}" = set; then
4837 >    INSTALL=$ac_cv_path_install
4838 >  else
4839 >    # As a last resort, use the slow shell script.  Don't cache a
4840 >    # value for INSTALL within a source directory, because that will
4841 >    # break other packages using the cache if that directory is
4842 >    # removed, or if the value is a relative name.
4843 >    INSTALL=$ac_install_sh
4844 >  fi
4845 > fi
4846 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
4847 > $as_echo "$INSTALL" >&6; }
4848  
4849 + # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
4850 + # It thinks the first close brace ends the variable substitution.
4851 + test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
4852  
4853 < 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
4853 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
4854  
4855 < ac_ext=${ac_fc_srcext-f}
4856 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4857 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4858 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4859 < if test -n "$ac_tool_prefix"; then
4860 <  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
4861 <  do
4862 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4863 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4864 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4855 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
4856 >
4857 > case "x$INSTALL" in
4858 >   x/*) ;;
4859 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
4860 > esac
4861 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f -m 755"
4862 > # Extract the first word of "ar", so it can be a program name with args.
4863 > set dummy ar; ac_word=$2
4864 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4865   $as_echo_n "checking for $ac_word... " >&6; }
4866 < if test "${ac_cv_prog_FC+set}" = set; then
4866 > if ${ac_cv_prog_AR+:} false; then :
4867    $as_echo_n "(cached) " >&6
4868   else
4869 <  if test -n "$FC"; then
4870 <  ac_cv_prog_FC="$FC" # Let the user override the test.
4869 >  if test -n "$AR"; then
4870 >  ac_cv_prog_AR="$AR" # Let the user override the test.
4871   else
4872   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4873   for as_dir in $PATH
4874   do
4875    IFS=$as_save_IFS
4876    test -z "$as_dir" && as_dir=.
4877 <  for ac_exec_ext in '' $ac_executable_extensions; do
4877 >    for ac_exec_ext in '' $ac_executable_extensions; do
4878    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4879 <    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4880 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4879 >    ac_cv_prog_AR="ar"
4880 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4881      break 2
4882    fi
4883   done
4884 < done
4884 >  done
4885   IFS=$as_save_IFS
4886  
4887 +  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
4888   fi
4889   fi
4890 < FC=$ac_cv_prog_FC
4891 < if test -n "$FC"; then
4892 <  { $as_echo "$as_me:$LINENO: result: $FC" >&5
4893 < $as_echo "$FC" >&6; }
4890 > AR=$ac_cv_prog_AR
4891 > if test -n "$AR"; then
4892 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
4893 > $as_echo "$AR" >&6; }
4894   else
4895 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4895 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4896   $as_echo "no" >&6; }
4897   fi
4898  
4899  
4900 <    test -n "$FC" && break
4901 <  done
4902 < fi
4903 < if test -z "$FC"; then
4904 <  ac_ct_FC=$FC
4905 <  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
4906 < do
4907 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4908 < set dummy $ac_prog; ac_word=$2
4909 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
4910 < $as_echo_n "checking for $ac_word... " >&6; }
4911 < if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4912 <  $as_echo_n "(cached) " >&6
4913 < 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
4900 > if test "$AR" = "NONE"; then
4901 >  cat >confcache <<\_ACEOF
4902 > # This file is a shell script that caches the results of configure
4903 > # tests run on this system so they can be shared between configure
4904 > # scripts and configure runs, see configure's option --config-cache.
4905 > # It is not useful on other systems.  If it contains results you don't
4906 > # want to keep, you may remove or edit it.
4907 > #
4908 > # config.status only pays attention to the cache file if you give it
4909 > # the --recheck option to rerun configure.
4910 > #
4911 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
4912 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
4913 > # following values.
4914  
4915 < fi
4916 < fi
4917 < ac_ct_FC=$ac_cv_prog_ac_ct_FC
4918 < if test -n "$ac_ct_FC"; then
4919 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
4920 < $as_echo "$ac_ct_FC" >&6; }
4921 < else
4922 <  { $as_echo "$as_me:$LINENO: result: no" >&5
4923 < $as_echo "no" >&6; }
4924 < fi
4915 > _ACEOF
4916 >
4917 > # The following way of writing the cache mishandles newlines in values,
4918 > # but we know of no workaround that is simple, portable, and efficient.
4919 > # So, we kill variables containing newlines.
4920 > # Ultrix sh set writes to stderr and can't be redirected directly,
4921 > # and sets the high bit in the cache file unless we assign to the vars.
4922 > (
4923 >  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
4924 >    eval ac_val=\$$ac_var
4925 >    case $ac_val in #(
4926 >    *${as_nl}*)
4927 >      case $ac_var in #(
4928 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
4929 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
4930 >      esac
4931 >      case $ac_var in #(
4932 >      _ | IFS | as_nl) ;; #(
4933 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
4934 >      *) { eval $ac_var=; unset $ac_var;} ;;
4935 >      esac ;;
4936 >    esac
4937 >  done
4938  
4939 <
4940 <  test -n "$ac_ct_FC" && break
4941 < done
4942 <
4943 <  if test "x$ac_ct_FC" = x; then
4944 <    FC=""
4939 >  (set) 2>&1 |
4940 >    case $as_nl`(ac_space=' '; set) 2>&1` in #(
4941 >    *${as_nl}ac_space=\ *)
4942 >      # `set' does not quote correctly, so add quotes: double-quote
4943 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
4944 >      sed -n \
4945 >        "s/'/'\\\\''/g;
4946 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4947 >      ;; #(
4948 >    *)
4949 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
4950 >      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
4951 >      ;;
4952 >    esac |
4953 >    sort
4954 > ) |
4955 >  sed '
4956 >     /^ac_cv_env_/b end
4957 >     t clear
4958 >     :clear
4959 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4960 >     t end
4961 >     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4962 >     :end' >>confcache
4963 > if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
4964 >  if test -w "$cache_file"; then
4965 >    if test "x$cache_file" != "x/dev/null"; then
4966 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
4967 > $as_echo "$as_me: updating cache $cache_file" >&6;}
4968 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
4969 >        cat confcache >"$cache_file"
4970 >      else
4971 >        case $cache_file in #(
4972 >        */* | ?:*)
4973 >          mv -f confcache "$cache_file"$$ &&
4974 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
4975 >        *)
4976 >          mv -f confcache "$cache_file" ;;
4977 >        esac
4978 >      fi
4979 >    fi
4980    else
4981 <    case $cross_compiling:$ac_tool_warned in
4982 < 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
4981 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
4982 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
4983    fi
4984   fi
4985 + rm -f confcache
4986 +  exit 1
4987 + fi
4988  
4989  
4990 < # Provide some information about the compiler.
4991 < $as_echo "$as_me:$LINENO: checking for Fortran compiler version" >&5
4992 < 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
4990 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
4991 > $as_echo_n "checking for ANSI C header files... " >&6; }
4992 > if ${ac_cv_header_stdc+:} false; then :
4993    $as_echo_n "(cached) " >&6
4994   else
4995 <  cat >conftest.$ac_ext <<_ACEOF
4996 <      program main
4997 < #ifndef __GNUC__
4998 <       choke me
4999 < #endif
4995 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4996 > /* end confdefs.h.  */
4997 > #include <stdlib.h>
4998 > #include <stdarg.h>
4999 > #include <string.h>
5000 > #include <float.h>
5001  
5002 <      end
5002 > int
5003 > main ()
5004 > {
5005 >
5006 >  ;
5007 >  return 0;
5008 > }
5009   _ACEOF
5010 < rm -f conftest.$ac_objext
5011 < 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
5010 > if ac_fn_c_try_compile "$LINENO"; then :
5011 >  ac_cv_header_stdc=yes
5012   else
5013 <  $as_echo "$as_me: failed program was:" >&5
4658 < sed 's/^/| /' conftest.$ac_ext >&5
4659 <
4660 <        ac_compiler_gnu=no
5013 >  ac_cv_header_stdc=no
5014   fi
4662 –
5015   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4664 – ac_cv_fc_compiler_gnu=$ac_compiler_gnu
5016  
5017 < fi
5018 < { $as_echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
5019 < $as_echo "$ac_cv_fc_compiler_gnu" >&6; }
5020 < ac_ext=$ac_save_ext
5021 < 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
5017 > if test $ac_cv_header_stdc = yes; then
5018 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5019 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5020 > /* end confdefs.h.  */
5021 > #include <string.h>
5022  
4682 –      end
5023   _ACEOF
5024 < rm -f conftest.$ac_objext
5025 < if { (ac_try="$ac_compile"
5026 < 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
5024 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5025 >  $EGREP "memchr" >/dev/null 2>&1; then :
5026 >
5027   else
5028 <  $as_echo "$as_me: failed program was:" >&5
5029 < sed 's/^/| /' conftest.$ac_ext >&5
5028 >  ac_cv_header_stdc=no
5029 > fi
5030 > rm -f conftest*
5031  
4707 –        ac_cv_prog_fc_g=no
5032   fi
5033  
5034 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5034 > if test $ac_cv_header_stdc = yes; then
5035 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5036 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5037 > /* end confdefs.h.  */
5038 > #include <stdlib.h>
5039  
5040 + _ACEOF
5041 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5042 +  $EGREP "free" >/dev/null 2>&1; then :
5043 +
5044 + else
5045 +  ac_cv_header_stdc=no
5046   fi
5047 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
5048 < $as_echo "$ac_cv_prog_fc_g" >&6; }
5049 < if test "$ac_test_FFLAGS" = set; then
5050 <  FCFLAGS=$ac_save_FFLAGS
5051 < elif test $ac_cv_prog_fc_g = yes; then
5052 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5053 <    FCFLAGS="-g -O2"
5054 <  else
4721 <    FCFLAGS="-g"
4722 <  fi
5047 > rm -f conftest*
5048 >
5049 > fi
5050 >
5051 > if test $ac_cv_header_stdc = yes; then
5052 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5053 >  if test "$cross_compiling" = yes; then :
5054 >  :
5055   else
5056 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5057 <    FCFLAGS="-O2"
5056 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5057 > /* end confdefs.h.  */
5058 > #include <ctype.h>
5059 > #include <stdlib.h>
5060 > #if ((' ' & 0x0FF) == 0x020)
5061 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5062 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5063 > #else
5064 > # define ISLOWER(c) \
5065 >                   (('a' <= (c) && (c) <= 'i') \
5066 >                     || ('j' <= (c) && (c) <= 'r') \
5067 >                     || ('s' <= (c) && (c) <= 'z'))
5068 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5069 > #endif
5070 >
5071 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5072 > int
5073 > main ()
5074 > {
5075 >  int i;
5076 >  for (i = 0; i < 256; i++)
5077 >    if (XOR (islower (i), ISLOWER (i))
5078 >        || toupper (i) != TOUPPER (i))
5079 >      return 2;
5080 >  return 0;
5081 > }
5082 > _ACEOF
5083 > if ac_fn_c_try_run "$LINENO"; then :
5084 >
5085 > else
5086 >  ac_cv_header_stdc=no
5087 > fi
5088 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
5089 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
5090 > fi
5091 >
5092 > fi
5093 > fi
5094 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
5095 > $as_echo "$ac_cv_header_stdc" >&6; }
5096 > if test $ac_cv_header_stdc = yes; then
5097 >
5098 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
5099 >
5100 > fi
5101 >
5102 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5103 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5104 >                  inttypes.h stdint.h unistd.h
5105 > do :
5106 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
5107 > ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
5108 > "
5109 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
5110 >  cat >>confdefs.h <<_ACEOF
5111 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
5112 > _ACEOF
5113 >
5114 > fi
5115 >
5116 > done
5117 >
5118 >
5119 > #
5120 > # Handle user hints
5121 > #
5122 >
5123 > # Check whether --with-zlib was given.
5124 > if test "${with_zlib+set}" = set; then :
5125 >  withval=$with_zlib; zlib_dir="$withval"
5126 > else
5127 >                zlib_dir="not_set"
5128 > fi
5129 >
5130 > if test "$zlib_dir" != "no"; then
5131 >
5132 > if test "$zlib_dir" != "not_set" ; then
5133 >  if test -d "$zlib_dir"
5134 >  then
5135 >    ZLIB_HOME="$zlib_dir"
5136    else
5137 <    FCFLAGS=
5137 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5138 > $as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5139 >        ZLIB_HOME=/usr/local
5140 >        if test ! -f "${ZLIB_HOME}/include/zlib.h"
5141 >        then
5142 >                ZLIB_HOME=/usr
5143 >        fi
5144    fi
5145   fi
5146 + #
5147 + # Locate zlib, if wanted
5148 + #
5149 + if test -n "${ZLIB_HOME}"
5150 + then
5151 +        ZLIB_OLD_LDFLAGS=$LDFLAGS
5152 +        ZLIB_OLD_CFLAGS=$CFLAGS
5153 +        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5154 +        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
5155  
5156 < ac_ext=c
5156 >        ac_ext=c
5157   ac_cpp='$CPP $CPPFLAGS'
5158   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5159   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5160   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5161  
5162 < ac_ext=c
5163 < ac_cpp='$CPP $CPPFLAGS'
5164 < 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
5162 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inflateEnd in -lz" >&5
5163 > $as_echo_n "checking for inflateEnd in -lz... " >&6; }
5164 > if ${ac_cv_lib_z_inflateEnd+:} false; then :
5165    $as_echo_n "(cached) " >&6
5166   else
5167 <      # Double quotes because CPP needs to be expanded
5168 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5169 <    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
5167 >  ac_check_lib_save_LIBS=$LIBS
5168 > LIBS="-lz  $LIBS"
5169 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5170   /* end confdefs.h.  */
5171 < #ifdef __STDC__
5172 < # include <limits.h>
5173 < #else
5174 < # include <assert.h>
5171 >
5172 > /* Override any GCC internal prototype to avoid an error.
5173 >   Use char because int might match the return type of a GCC
5174 >   builtin and then its argument prototype would still apply.  */
5175 > #ifdef __cplusplus
5176 > extern "C"
5177   #endif
5178 <                     Syntax error
5178 > char inflateEnd ();
5179 > int
5180 > main ()
5181 > {
5182 > return inflateEnd ();
5183 >  ;
5184 >  return 0;
5185 > }
5186   _ACEOF
5187 < if { (ac_try="$ac_cpp conftest.$ac_ext"
5188 < 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 <  :
5187 > if ac_fn_c_try_link "$LINENO"; then :
5188 >  ac_cv_lib_z_inflateEnd=yes
5189   else
5190 <  $as_echo "$as_me: failed program was:" >&5
5191 < sed 's/^/| /' conftest.$ac_ext >&5
5190 >  ac_cv_lib_z_inflateEnd=no
5191 > fi
5192 > rm -f core conftest.err conftest.$ac_objext \
5193 >    conftest$ac_exeext conftest.$ac_ext
5194 > LIBS=$ac_check_lib_save_LIBS
5195 > fi
5196 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_inflateEnd" >&5
5197 > $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
5198 > if test "x$ac_cv_lib_z_inflateEnd" = xyes; then :
5199 >  zlib_cv_libz=yes
5200 > else
5201 >  zlib_cv_libz=no
5202 > fi
5203  
5204 <  # Broken: fails on valid input.
5205 < continue
5204 >        ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
5205 > if test "x$ac_cv_header_zlib_h" = xyes; then :
5206 >  zlib_cv_zlib_h=yes
5207 > else
5208 >  zlib_cv_zlib_h=no
5209   fi
5210  
4803 – rm -f conftest.err conftest.$ac_ext
5211  
5212 <  # OK, works on sane cases.  Now check whether nonexistent headers
5213 <  # can be detected and how.
5214 <  cat >conftest.$ac_ext <<_ACEOF
5215 < /* confdefs.h.  */
5216 < _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
5212 >        ac_ext=c
5213 > ac_cpp='$CPP $CPPFLAGS'
5214 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5215 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5216 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5217  
4838 –  # Passes both tests.
4839 – ac_preproc_ok=:
4840 – break
4841 – fi
5218  
5219 < rm -f conftest.err conftest.$ac_ext
5219 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
5220  
5221 < 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
5221 > $as_echo "#define HAVE_ZLIB_H 1" >>confdefs.h
5222  
4852 –    done
4853 –    ac_cv_prog_CPP=$CPP
5223  
5224 < fi
5225 <  CPP=$ac_cv_prog_CPP
5226 < else
5227 <  ac_cv_prog_CPP=$CPP
5228 < fi
5229 < { $as_echo "$as_me:$LINENO: result: $CPP" >&5
5230 < $as_echo "$CPP" >&6; }
5231 < ac_preproc_ok=false
5232 < for ac_c_preproc_warn_flag in '' yes
5233 < do
5234 <  # Use a header file that comes with gcc, so configuring glibc
5235 <  # with a fresh cross-compiler works.
5236 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5237 <  # <limits.h> exists even on freestanding compilers.
5238 <  # On the NeXT, cc -E runs the code through the compiler's parser,
5239 <  # not just through cpp. "Syntax error" is here to catch this case.
5240 <  cat >conftest.$ac_ext <<_ACEOF
5241 < /* confdefs.h.  */
5242 < _ACEOF
5243 < cat confdefs.h >>conftest.$ac_ext
5244 < cat >>conftest.$ac_ext <<_ACEOF
5245 < /* end confdefs.h.  */
5246 < #ifdef __STDC__
5247 < # include <limits.h>
5248 < #else
5249 < # 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
5224 > $as_echo "#define HAVE_LIBZ 1" >>confdefs.h
5225 >
5226 >                ZLIB_INC_DIR="${ZLIB_HOME}/include"
5227 >                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
5228 >                ZLIB="-lz"
5229 >        else
5230 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking zlib in ${ZLIB_HOME}" >&5
5231 > $as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
5232 >                ZLIB_INC_DIR=
5233 >                ZLIB_LIB_DIR=
5234 >                ZLIB=
5235 >                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5236 >                CFLAGS="$ZLIB_OLD_CFLAGS"
5237 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5238 > $as_echo "failed" >&6; }
5239 >                echo ""
5240 >                echo "*********************************************************"
5241 >                echo "* WARNING: Could not find a working zlib installation   *"
5242 >                echo "* If you need OpenMD to be able to deal with compressed *"
5243 >                echo "* trajectory dump files be sure to specify a valid zlib *"
5244 >                echo "* installation with --with-zlib=DIR                     *"
5245 >                echo "*                                                       *"
5246 >                echo "* OpenMD will still work without zlib installed.        *"
5247 >                echo "*********************************************************"
5248 >                echo ""
5249 >        fi
5250  
4906 –  # Broken: fails on valid input.
4907 – continue
4908 – fi
5251  
4910 – rm -f conftest.err conftest.$ac_ext
5252  
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
5253   fi
5254 + fi
5255  
5256 < rm -f conftest.err conftest.$ac_ext
5256 > #
5257 > # Handle user hints
5258 > #
5259  
5260 < done
5261 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5262 < rm -f conftest.err conftest.$ac_ext
4955 < if $ac_preproc_ok; then
4956 <  :
5260 > # Check whether --with-fftw was given.
5261 > if test "${with_fftw+set}" = set; then :
5262 >  withval=$with_fftw; fftw_dir="$withval"
5263   else
5264 <  { { $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; }; }
5264 >             fftw_dir="not_set"
5265   fi
5266  
5267 < ac_ext=c
5267 > if test "$fftw_dir" != "no"; then
5268 >  if test "$fftw_dir" != "not_set" ; then
5269 >    if test -d "$fftw_dir"; then
5270 >      FFTW_HOME="$fftw_dir"
5271 >    else
5272 >      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
5273 > $as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
5274 >      FFTW_HOME=/usr/local
5275 >      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
5276 >        FFTW_HOME=/usr
5277 >      fi
5278 >    fi
5279 >    #
5280 >    # Locate fftw, if wanted
5281 >    #
5282 >    if test -n "${FFTW_HOME}"; then
5283 >      FFTW_OLD_LDFLAGS=$LDFLAGS
5284 >      FFTW_OLD_CFLAGS=$CFLAGS
5285 >      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
5286 >      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
5287 >
5288 >      ac_ext=c
5289   ac_cpp='$CPP $CPPFLAGS'
5290   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5291   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5292   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5293  
5294 < { $as_echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
5295 < $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
5296 < if test "${ac_cv_path_GREP+set}" = set; then
5294 >      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
5295 > $as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
5296 > if ${ac_cv_lib_fftw3_fftw_execute+:} false; then :
5297    $as_echo_n "(cached) " >&6
5298   else
5299 <  if test -z "$GREP"; then
5300 <  ac_path_GREP_found=false
5301 <  # Loop through the user's path and test for each of PROGNAME-LIST
5302 <  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
5299 >  ac_check_lib_save_LIBS=$LIBS
5300 > LIBS="-lfftw3  $LIBS"
5301 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5302 > /* end confdefs.h.  */
5303  
5304 <      $ac_path_GREP_found && break 3
5305 <    done
5306 <  done
5307 < done
5308 < IFS=$as_save_IFS
5309 <  if test -z "$ac_cv_path_GREP"; then
5310 <    { { $as_echo "$as_me:$LINENO: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5311 < $as_echo "$as_me: error: no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5312 <   { (exit 1); exit 1; }; }
5313 <  fi
5304 > /* Override any GCC internal prototype to avoid an error.
5305 >   Use char because int might match the return type of a GCC
5306 >   builtin and then its argument prototype would still apply.  */
5307 > #ifdef __cplusplus
5308 > extern "C"
5309 > #endif
5310 > char fftw_execute ();
5311 > int
5312 > main ()
5313 > {
5314 > return fftw_execute ();
5315 >  ;
5316 >  return 0;
5317 > }
5318 > _ACEOF
5319 > if ac_fn_c_try_link "$LINENO"; then :
5320 >  ac_cv_lib_fftw3_fftw_execute=yes
5321   else
5322 <  ac_cv_path_GREP=$GREP
5322 >  ac_cv_lib_fftw3_fftw_execute=no
5323   fi
5324 + rm -f core conftest.err conftest.$ac_objext \
5325 +    conftest$ac_exeext conftest.$ac_ext
5326 + LIBS=$ac_check_lib_save_LIBS
5327 + fi
5328 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
5329 + $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
5330 + if test "x$ac_cv_lib_fftw3_fftw_execute" = xyes; then :
5331 +  fftw_cv_libfftw3=yes
5332 + else
5333 +  fftw_cv_libfftw3=no
5334 + fi
5335  
5336 +      ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
5337 + if test "x$ac_cv_header_fftw3_h" = xyes; then :
5338 +  fftw_cv_fftw3_h=yes
5339 + else
5340 +  fftw_cv_fftw3_h=no
5341   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"
5342  
5343  
5344 < { $as_echo "$as_me:$LINENO: checking for egrep" >&5
5345 < $as_echo_n "checking for egrep... " >&6; }
5346 < if test "${ac_cv_path_EGREP+set}" = set; then
5347 <  $as_echo_n "(cached) " >&6
5348 < else
5349 <  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
5350 <   then ac_cv_path_EGREP="$GREP -E"
5351 <   else
5352 <     if test -z "$EGREP"; then
5353 <  ac_path_EGREP_found=false
5354 <  # Loop through the user's path and test for each of PROGNAME-LIST
5355 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5356 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
5357 < do
5358 <  IFS=$as_save_IFS
5359 <  test -z "$as_dir" && as_dir=.
5360 <  for ac_prog in egrep; do
5361 <    for ac_exec_ext in '' $ac_executable_extensions; do
5362 <      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
5363 <      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
5364 < # Check for GNU ac_path_EGREP and select it if it is found.
5365 <  # Check for GNU $ac_path_EGREP
5366 < case `"$ac_path_EGREP" --version 2>&1` in
5367 < *GNU*)
5368 <  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
5369 < *)
5370 <  ac_count=0
5371 <  $as_echo_n 0123456789 >"conftest.in"
5372 <  while :
5373 <  do
5374 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
5375 <    mv "conftest.tmp" "conftest.in"
5376 <    cp "conftest.in" "conftest.nl"
5377 <    $as_echo 'EGREP' >> "conftest.nl"
5378 <    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
5379 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
5380 <    ac_count=`expr $ac_count + 1`
5381 <    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
5382 <      # Best one so far, save it but keep looking for a better one
5383 <      ac_cv_path_EGREP="$ac_path_EGREP"
5384 <      ac_path_EGREP_max=$ac_count
5385 <    fi
5386 <    # 10*(2^10) chars as input seems more than enough
5387 <    test $ac_count -gt 10 && break
5388 <  done
5389 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
5390 < esac
5391 <
5392 <      $ac_path_EGREP_found && break 3
5393 <    done
5394 <  done
5395 < done
5396 < IFS=$as_save_IFS
5397 <  if test -z "$ac_cv_path_EGREP"; then
5398 <    { { $as_echo "$as_me:$LINENO: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
5399 < $as_echo "$as_me: error: no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
5400 <   { (exit 1); exit 1; }; }
5401 <  fi
5402 < else
5403 <  ac_cv_path_EGREP=$EGREP
5404 < fi
5405 <
5406 <   fi
5407 < fi
5408 < { $as_echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
5409 < $as_echo "$ac_cv_path_EGREP" >&6; }
5410 < EGREP="$ac_cv_path_EGREP"
5411 <
5412 <
5413 < { $as_echo "$as_me:$LINENO: checking whether ln -s works" >&5
5414 < $as_echo_n "checking whether ln -s works... " >&6; }
5415 < LN_S=$as_ln_s
5416 < if test "$LN_S" = "ln -s"; then
5417 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
5418 < $as_echo "yes" >&6; }
5419 < else
5420 <  { $as_echo "$as_me:$LINENO: result: no, using $LN_S" >&5
5421 < $as_echo "no, using $LN_S" >&6; }
5422 < fi
5423 <
5424 < { $as_echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
5425 < $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
5426 < set x ${MAKE-make}
5427 < ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
5428 < if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
5429 <  $as_echo_n "(cached) " >&6
5430 < else
5431 <  cat >conftest.make <<\_ACEOF
5432 < SHELL = /bin/sh
5433 < all:
5434 <        @echo '@@@%%%=$(MAKE)=@@@%%%'
5435 < _ACEOF
5436 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
5437 < case `${MAKE-make} -f conftest.make 2>/dev/null` in
5438 <  *@@@%%%=?*=@@@%%%*)
5439 <    eval ac_cv_prog_make_${ac_make}_set=yes;;
5440 <  *)
5441 <    eval ac_cv_prog_make_${ac_make}_set=no;;
5442 < esac
5443 < rm -f conftest.make
5444 < fi
5445 < if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
5446 <  { $as_echo "$as_me:$LINENO: result: yes" >&5
5447 < $as_echo "yes" >&6; }
5448 <  SET_MAKE=
5449 < else
5450 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5451 < $as_echo "no" >&6; }
5452 <  SET_MAKE="MAKE=${MAKE-make}"
5453 < fi
5454 <
5455 < if test -n "$ac_tool_prefix"; then
5456 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
5457 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
5458 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5459 < $as_echo_n "checking for $ac_word... " >&6; }
5460 < if test "${ac_cv_prog_RANLIB+set}" = set; then
5461 <  $as_echo_n "(cached) " >&6
5462 < else
5463 <  if test -n "$RANLIB"; then
5464 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
5465 < else
5466 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5467 < for as_dir in $PATH
5468 < do
5469 <  IFS=$as_save_IFS
5470 <  test -z "$as_dir" && as_dir=.
5471 <  for ac_exec_ext in '' $ac_executable_extensions; do
5472 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5473 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
5474 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5475 <    break 2
5476 <  fi
5477 < done
5478 < done
5479 < IFS=$as_save_IFS
5480 <
5481 < fi
5482 < fi
5483 < RANLIB=$ac_cv_prog_RANLIB
5484 < if test -n "$RANLIB"; then
5485 <  { $as_echo "$as_me:$LINENO: result: $RANLIB" >&5
5486 < $as_echo "$RANLIB" >&6; }
5487 < else
5488 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5489 < $as_echo "no" >&6; }
5490 < fi
5491 <
5492 <
5493 < fi
5494 < if test -z "$ac_cv_prog_RANLIB"; then
5495 <  ac_ct_RANLIB=$RANLIB
5496 <  # Extract the first word of "ranlib", so it can be a program name with args.
5497 < set dummy ranlib; ac_word=$2
5498 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5499 < $as_echo_n "checking for $ac_word... " >&6; }
5500 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
5501 <  $as_echo_n "(cached) " >&6
5502 < else
5503 <  if test -n "$ac_ct_RANLIB"; then
5504 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
5505 < else
5506 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5507 < for as_dir in $PATH
5508 < do
5509 <  IFS=$as_save_IFS
5510 <  test -z "$as_dir" && as_dir=.
5511 <  for ac_exec_ext in '' $ac_executable_extensions; do
5512 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5513 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
5514 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5515 <    break 2
5516 <  fi
5517 < done
5518 < done
5519 < IFS=$as_save_IFS
5520 <
5521 < fi
5522 < fi
5523 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
5524 < if test -n "$ac_ct_RANLIB"; then
5525 <  { $as_echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
5526 < $as_echo "$ac_ct_RANLIB" >&6; }
5527 < else
5528 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5529 < $as_echo "no" >&6; }
5530 < fi
5531 <
5532 <  if test "x$ac_ct_RANLIB" = x; then
5533 <    RANLIB=":"
5534 <  else
5535 <    case $cross_compiling:$ac_tool_warned in
5536 < yes:)
5537 < { $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
5538 < whose name does not start with the host triplet.  If you think this
5539 < configuration is useful to you, please write to autoconf@gnu.org." >&5
5540 < $as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
5541 < whose name does not start with the host triplet.  If you think this
5542 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
5543 < ac_tool_warned=yes ;;
5544 < esac
5545 <    RANLIB=$ac_ct_RANLIB
5546 <  fi
5547 < else
5548 <  RANLIB="$ac_cv_prog_RANLIB"
5549 < fi
5550 <
5551 <
5552 <   # Extract the first word of "perl", so it can be a program name with args.
5553 < set dummy perl; ac_word=$2
5554 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5555 < $as_echo_n "checking for $ac_word... " >&6; }
5556 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
5557 <  $as_echo_n "(cached) " >&6
5558 < else
5559 <  case $PERLINTERP in
5560 <  [\\/]* | ?:[\\/]*)
5561 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
5562 <  ;;
5563 <  *)
5564 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5565 < for as_dir in $PATH
5566 < do
5567 <  IFS=$as_save_IFS
5568 <  test -z "$as_dir" && as_dir=.
5569 <  for ac_exec_ext in '' $ac_executable_extensions; do
5570 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5571 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
5572 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5573 <    break 2
5574 <  fi
5575 < done
5576 < done
5577 < IFS=$as_save_IFS
5578 <
5579 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
5580 <  ;;
5581 < esac
5582 < fi
5583 < PERLINTERP=$ac_cv_path_PERLINTERP
5584 < if test -n "$PERLINTERP"; then
5585 <  { $as_echo "$as_me:$LINENO: result: $PERLINTERP" >&5
5586 < $as_echo "$PERLINTERP" >&6; }
5587 < else
5588 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5589 < $as_echo "no" >&6; }
5590 < fi
5591 <
5592 <
5593 <   ac_cv_path_perlinterp="$PERLINTERP"
5594 <   _sHpB='#!'
5595 <
5596 <
5597 < # Check whether --with-perl-shebang was given.
5598 < if test "${with_perl_shebang+set}" = set; then
5599 <  withval=$with_perl_shebang; opt_perl_shebang="$withval"
5600 < else
5601 <                opt_perl_shebang="not_set"
5602 < fi
5603 <
5604 <   { $as_echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
5605 < $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
5606 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
5607 <  $as_echo_n "(cached) " >&6
5608 < else
5609 <   case "$opt_perl_shebang" in
5610 <                      not_set  ) ax_cv_opt_perl_shebang=''
5611 <                               ;;
5612 <                         *     )
5613 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
5614 <                    esac
5615 <
5616 < fi
5617 < { $as_echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
5618 < $as_echo "$ax_cv_opt_perl_shebang" >&6; }
5619 <   if test "A$ax_cv_opt_perl_shebang" != "A"
5620 <     then
5621 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
5622 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
5623 <              { $as_echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
5624 < $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
5625 <
5626 < # Automatic detection of sharpbang formula starts here
5627 <     else
5628 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
5629 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
5630 <   { $as_echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
5631 < $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
5632 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
5633 <  $as_echo_n "(cached) " >&6
5634 < else
5635 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
5636 <        if test "x$_somian_kspb_perl" == x
5637 <          then _somian_ksbp_warn_empty='durnit'
5638 <          else
5639 <          case "A$_somian_kspb_perl" in
5640 <                 A#!*perl* )
5641 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
5642 <                        ;;
5643 <                     A*    )  _somian_ksbp_warn_defau='trouble'
5644 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
5645 <          esac
5646 <        fi
5647 <
5648 < fi
5649 < { $as_echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
5650 < $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
5651 < # The above prints Checking ... result message to user.
5652 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
5653 <
5654 <    if test A${_somian_ksbp_warn_empty+set} == Aset
5655 <      then   { $as_echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
5656 < $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
5657 <    fi
5658 < # Inform user after printing result value
5659 <    if test A${_somian_ksbp_warn_defau+set} == Aset
5660 <      then { $as_echo "$as_me:$LINENO: Maybe Not good -" >&5
5661 < $as_echo "$as_me: Maybe Not good -" >&6;}
5662 <           { $as_echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
5663 < $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
5664 <      else { $as_echo "$as_me:$LINENO: OK Good result - " >&5
5665 < $as_echo "$as_me: OK Good result - " >&6;}
5666 <           { $as_echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
5667 < $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
5668 <    fi
5669 <  fi
5670 <
5671 < # Find a good install program.  We prefer a C program (faster),
5672 < # so one script is as good as another.  But avoid the broken or
5673 < # incompatible versions:
5674 < # SysV /etc/install, /usr/sbin/install
5675 < # SunOS /usr/etc/install
5676 < # IRIX /sbin/install
5677 < # AIX /bin/install
5678 < # AmigaOS /C/install, which installs bootblocks on floppy discs
5679 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
5680 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
5681 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
5682 < # OS/2's system install, which has a completely different semantic
5683 < # ./install, which can be erroneously created by make from ./install.sh.
5684 < # Reject install programs that cannot install multiple files.
5685 < { $as_echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
5686 < $as_echo_n "checking for a BSD-compatible install... " >&6; }
5687 < if test -z "$INSTALL"; then
5688 < if test "${ac_cv_path_install+set}" = set; then
5689 <  $as_echo_n "(cached) " >&6
5690 < else
5691 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5692 < for as_dir in $PATH
5693 < do
5694 <  IFS=$as_save_IFS
5695 <  test -z "$as_dir" && as_dir=.
5696 <  # Account for people who put trailing slashes in PATH elements.
5697 < case $as_dir/ in
5698 <  ./ | .// | /cC/* | \
5699 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
5700 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
5701 <  /usr/ucb/* ) ;;
5702 <  *)
5703 <    # OSF1 and SCO ODT 3.0 have their own names for install.
5704 <    # Don't use installbsd from OSF since it installs stuff as root
5705 <    # by default.
5706 <    for ac_prog in ginstall scoinst install; do
5707 <      for ac_exec_ext in '' $ac_executable_extensions; do
5708 <        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
5709 <          if test $ac_prog = install &&
5710 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
5711 <            # AIX install.  It has an incompatible calling convention.
5712 <            :
5713 <          elif test $ac_prog = install &&
5714 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
5715 <            # program-specific install script used by HP pwplus--don't use.
5716 <            :
5717 <          else
5718 <            rm -rf conftest.one conftest.two conftest.dir
5719 <            echo one > conftest.one
5720 <            echo two > conftest.two
5721 <            mkdir conftest.dir
5722 <            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
5723 <              test -s conftest.one && test -s conftest.two &&
5724 <              test -s conftest.dir/conftest.one &&
5725 <              test -s conftest.dir/conftest.two
5726 <            then
5727 <              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
5728 <              break 3
5729 <            fi
5730 <          fi
5731 <        fi
5732 <      done
5733 <    done
5734 <    ;;
5735 < esac
5736 <
5737 < done
5738 < IFS=$as_save_IFS
5739 <
5740 < rm -rf conftest.one conftest.two conftest.dir
5741 <
5742 < fi
5743 <  if test "${ac_cv_path_install+set}" = set; then
5744 <    INSTALL=$ac_cv_path_install
5745 <  else
5746 <    # As a last resort, use the slow shell script.  Don't cache a
5747 <    # value for INSTALL within a source directory, because that will
5748 <    # break other packages using the cache if that directory is
5749 <    # removed, or if the value is a relative name.
5750 <    INSTALL=$ac_install_sh
5751 <  fi
5752 < fi
5753 < { $as_echo "$as_me:$LINENO: result: $INSTALL" >&5
5754 < $as_echo "$INSTALL" >&6; }
5755 <
5756 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
5757 < # It thinks the first close brace ends the variable substitution.
5758 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
5759 <
5760 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
5761 <
5762 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
5763 <
5764 < case "x$INSTALL" in
5765 <   x/*) ;;
5766 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
5767 < esac
5768 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
5769 < # Extract the first word of "ar", so it can be a program name with args.
5770 < set dummy ar; ac_word=$2
5771 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5772 < $as_echo_n "checking for $ac_word... " >&6; }
5773 < if test "${ac_cv_prog_AR+set}" = set; then
5774 <  $as_echo_n "(cached) " >&6
5775 < else
5776 <  if test -n "$AR"; then
5777 <  ac_cv_prog_AR="$AR" # Let the user override the test.
5778 < else
5779 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5780 < for as_dir in $PATH
5781 < do
5782 <  IFS=$as_save_IFS
5783 <  test -z "$as_dir" && as_dir=.
5784 <  for ac_exec_ext in '' $ac_executable_extensions; do
5785 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5786 <    ac_cv_prog_AR="ar"
5787 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5788 <    break 2
5789 <  fi
5790 < done
5791 < done
5792 < IFS=$as_save_IFS
5793 <
5794 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
5795 < fi
5796 < fi
5797 < AR=$ac_cv_prog_AR
5798 < if test -n "$AR"; then
5799 <  { $as_echo "$as_me:$LINENO: result: $AR" >&5
5800 < $as_echo "$AR" >&6; }
5801 < else
5802 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5803 < $as_echo "no" >&6; }
5804 < fi
5805 <
5806 <
5807 < if test "$AR" = "NONE"; then
5808 <  cat >confcache <<\_ACEOF
5809 < # This file is a shell script that caches the results of configure
5810 < # tests run on this system so they can be shared between configure
5811 < # scripts and configure runs, see configure's option --config-cache.
5812 < # It is not useful on other systems.  If it contains results you don't
5813 < # want to keep, you may remove or edit it.
5814 < #
5815 < # config.status only pays attention to the cache file if you give it
5816 < # the --recheck option to rerun configure.
5817 < #
5818 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
5819 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
5820 < # following values.
5821 <
5822 < _ACEOF
5823 <
5824 < # The following way of writing the cache mishandles newlines in values,
5825 < # but we know of no workaround that is simple, portable, and efficient.
5826 < # So, we kill variables containing newlines.
5827 < # Ultrix sh set writes to stderr and can't be redirected directly,
5828 < # and sets the high bit in the cache file unless we assign to the vars.
5829 < (
5830 <  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
5831 <    eval ac_val=\$$ac_var
5832 <    case $ac_val in #(
5833 <    *${as_nl}*)
5834 <      case $ac_var in #(
5835 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
5836 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
5837 <      esac
5838 <      case $ac_var in #(
5839 <      _ | IFS | as_nl) ;; #(
5840 <      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
5841 <      *) $as_unset $ac_var ;;
5842 <      esac ;;
5843 <    esac
5844 <  done
5845 <
5846 <  (set) 2>&1 |
5847 <    case $as_nl`(ac_space=' '; set) 2>&1` in #(
5848 <    *${as_nl}ac_space=\ *)
5849 <      # `set' does not quote correctly, so add quotes (double-quote
5850 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
5851 <      sed -n \
5852 <        "s/'/'\\\\''/g;
5853 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
5854 <      ;; #(
5855 <    *)
5856 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
5857 <      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
5858 <      ;;
5859 <    esac |
5860 <    sort
5861 < ) |
5862 <  sed '
5863 <     /^ac_cv_env_/b end
5864 <     t clear
5865 <     :clear
5866 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
5867 <     t end
5868 <     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
5869 <     :end' >>confcache
5870 < if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
5871 <  if test -w "$cache_file"; then
5872 <    test "x$cache_file" != "x/dev/null" &&
5873 <      { $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
5874 < $as_echo "$as_me: updating cache $cache_file" >&6;}
5875 <    cat confcache >$cache_file
5876 <  else
5877 <    { $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
5878 < $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
5879 <  fi
5880 < fi
5881 < rm -f confcache
5882 <  exit 1
5883 < fi
5884 < # Extract the first word of "ps", so it can be a program name with args.
5885 < set dummy ps; ac_word=$2
5886 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
5887 < $as_echo_n "checking for $ac_word... " >&6; }
5888 < if test "${ac_cv_path_PS+set}" = set; then
5889 <  $as_echo_n "(cached) " >&6
5890 < else
5891 <  case $PS in
5892 <  [\\/]* | ?:[\\/]*)
5893 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
5894 <  ;;
5895 <  *)
5896 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5897 < for as_dir in $PATH
5898 < do
5899 <  IFS=$as_save_IFS
5900 <  test -z "$as_dir" && as_dir=.
5901 <  for ac_exec_ext in '' $ac_executable_extensions; do
5902 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5903 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
5904 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5905 <    break 2
5906 <  fi
5907 < done
5908 < done
5909 < IFS=$as_save_IFS
5910 <
5911 <  ;;
5912 < esac
5913 < fi
5914 < PS=$ac_cv_path_PS
5915 < if test -n "$PS"; then
5916 <  { $as_echo "$as_me:$LINENO: result: $PS" >&5
5917 < $as_echo "$PS" >&6; }
5918 < else
5919 <  { $as_echo "$as_me:$LINENO: result: no" >&5
5920 < $as_echo "no" >&6; }
5921 < fi
5922 <
5923 <
5924 < { $as_echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
5925 < $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
5926 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
5927 <  $as_echo_n "(cached) " >&6
5928 < else
5929 <
5930 <        if $PS ax -o rss > /dev/null 2>&1; then
5931 <                ac_cv_prog_ps_ax=yes
5932 <        else
5933 <                ac_cv_prog_ps_ax=no
5934 <        fi
5935 <        if $PS -ef -o rss > /dev/null 2>&1; then
5936 <                ac_cv_prog_ps_ef=yes
5937 <        else
5938 <                ac_cv_prog_ps_ef=no
5939 <        fi
5940 <        if test "$ac_cv_prog_ps_ax" = yes; then
5941 <                ac_cv_prog_ps_syntax=BSD
5942 <        else
5943 <                if test "$ac_cv_prog_ps_ef" = yes; then
5944 <                        ac_cv_prog_ps_syntax=POSIX
5945 <                else
5946 <                        { { $as_echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
5947 < $as_echo "$as_me: error: Could not determine ps syntax" >&2;}
5948 <   { (exit 1); exit 1; }; }
5949 <                fi
5950 <        fi
5951 <
5952 < fi
5953 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
5954 < $as_echo "$ac_cv_prog_ps_syntax" >&6; }
5955 <
5956 < cat >>confdefs.h <<_ACEOF
5957 < #define PSCOMMAND $PS
5958 < _ACEOF
5959 <
5960 < if test "$ac_cv_prog_ps_syntax" = BSD; then
5961 <
5962 < cat >>confdefs.h <<\_ACEOF
5963 < #define PSTYPE_IS_BSD 1
5964 < _ACEOF
5965 <
5966 < else
5967 <   if test "$ac_cv_prog_ps_syntax" = POSIX; then
5968 <
5969 < cat >>confdefs.h <<\_ACEOF
5970 < #define PSTYPE_IS_POSIX 1
5971 < _ACEOF
5972 <
5973 <   else
5974 <       { { $as_echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
5975 < $as_echo "$as_me: error: Unknown ps syntax type!" >&2;}
5976 <   { (exit 1); exit 1; }; }
5977 <   fi
5978 < fi
5979 <
5980 < ac_ext=${ac_fc_srcext-f}
5981 < 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
7142 <
7143 <
7144 <
7145 < { $as_echo "$as_me:$LINENO: checking for module suffix" >&5
7146 < $as_echo_n "checking for module suffix... " >&6; }
7147 < rm -f conftest*
7148 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
7149 < rm -f work*
7150 < cat >conftest.$ac_ext <<EOF
7151 <        module conftest
7152 <        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
7184 < else
7185 <    { $as_echo "$as_me:$LINENO: result: unknown" >&5
7186 < $as_echo "unknown" >&6; }
7187 < fi
7188 <
7189 <
7190 <
7191 <
7192 <
7193 < # Check for module include path (some use -I, some (Solaris) use -M, some
7194 < # (absoft) use -p).
7195 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
7196 < # specified, work.pcl and work.pc are created.  However, if you specify
7197 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
7198 < # Use the module made above
7199 < { $as_echo "$as_me:$LINENO: checking for module directory path flag" >&5
7200 < $as_echo_n "checking for module directory path flag... " >&6; }
7201 < rm -f conftest*
7202 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
7203 < rm -f work*
7204 < cat >conftest.$ac_ext <<EOF
7205 <        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"
7255 <
7256 <        else
7257 <            # The version of the Intel compiler that I have refuses to let
7258 <            # 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
7267 <
7268 <
7269 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
7270 <   if test $madedir = 1 ; then rmdir conf ; fi
7271 < fi
7272 <
7273 <
7274 < { $as_echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
7275 < $as_echo_n "checking for Fortran 90 module file names... " >&6; }
7276 < if test "${ac_cv_f90_module_names+set}" = set; then
7277 <  $as_echo_n "(cached) " >&6
7278 < else
7279 <  ac_ext=${ac_fc_srcext-f}
7280 < 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 <  :
7330 < else
7331 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7332 < fi
7333 <
7334 <          ;;
7335 <      # look for new files derived from the module name,
7336 <      # with different case translation schemes
7337 <      *Bar*)
7338 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
7339 <            ac_exists=false
7340 <  for ac_i in $ac_cv_f90_module_names; do
7341 <    if test x"$ac_pat" = x"$ac_i"; then
7342 <      ac_exists=true
7343 <      break
7344 <    fi
7345 <  done
7346 <
7347 <  if test x"$ac_exists" = xtrue; then
7348 <  :
7349 < else
7350 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7351 < fi
7352 <
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
7363 <
7364 <  if test x"$ac_exists" = xtrue; then
7365 <  :
7366 < else
7367 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7368 < fi
7369 <
7370 <          ;;
7371 <      *BAR*)
7372 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
7373 <            ac_exists=false
7374 <  for ac_i in $ac_cv_f90_module_names; do
7375 <    if test x"$ac_pat" = x"$ac_i"; then
7376 <      ac_exists=true
7377 <      break
7378 <    fi
7379 <  done
7380 <
7381 <  if test x"$ac_exists" = xtrue; then
7382 <  :
7383 < else
7384 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7385 < fi
7386 <
7387 <          ;;
7388 <       # Other files - we have no idea how they are generated
7389 <       *)
7390 <          { $as_echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
7391 < $as_echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
7392 <          ;;
7393 <   esac
7394 < done
7395 < if test "x$ac_cv_f90_module_names" = "x"; then
7396 <  { $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
7399 <
7400 < else
7401 <  $as_echo "$as_me: failed program was:" >&5
7402 < 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;}
7407 < fi
7408 <
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
7417 <
7418 < fi
7419 < { $as_echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
7420 < $as_echo "$ac_cv_f90_module_names" >&6; } # AC_CACHE_CHECK
7421 <
7422 < # We now generate a shell script that will help us to figure out the correct
7423 < # module file names, using the value of ac_cv_f90_module_names
7424 <
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
7443 < fi
7444 <
7445 < while test \$# != 0; do
7446 <
7447 <  file=\$1
7448 <  shift
7449 <
7450 < # strip suffix
7451 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
7452 <
7453 <  test ! -f \$file && continue
7454 <
7455 < # 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\`
7459 <
7460 < # Here, the patterns for generating module file names were inserted by configure
7461 <  for trans in $ac_cv_f90_module_names; do
7462 <
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 <
7498 < ac_ext=c
7499 < ac_cpp='$CPP $CPPFLAGS'
7500 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7501 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7502 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7503 <
7504 <
7505 < 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
7514 < $as_echo_n "checking for asin in -lm... " >&6; }
7515 < if test "${ac_cv_lib_m_asin+set}" = set; then
7516 <  $as_echo_n "(cached) " >&6
7517 < else
7518 <  ac_check_lib_save_LIBS=$LIBS
7519 < LIBS="-lm  $LIBS"
7520 < cat >conftest.$ac_ext <<_ACEOF
7521 < /* confdefs.h.  */
7522 < _ACEOF
7523 < cat confdefs.h >>conftest.$ac_ext
7524 < cat >>conftest.$ac_ext <<_ACEOF
7525 < /* end confdefs.h.  */
7526 <
7527 < /* Override any GCC internal prototype to avoid an error.
7528 <   Use char because int might match the return type of a GCC
7529 <   builtin and then its argument prototype would still apply.  */
7530 < #ifdef __cplusplus
7531 < extern "C"
7532 < #endif
7533 < 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
7542 < int
7543 < main ()
7544 < {
7545 < return asin ();
7546 <  ;
7547 <  return 0;
7548 < }
7549 < _ACEOF
7550 < 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
7571 <  ac_cv_lib_m_asin=yes
7572 < else
7573 <  $as_echo "$as_me: failed program was:" >&5
7574 < sed 's/^/| /' conftest.$ac_ext >&5
7575 <
7576 <        ac_cv_lib_m_asin=no
7577 < fi
7578 <
7579 < rm -rf conftest.dSYM
7580 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7581 <      conftest$ac_exeext conftest.$ac_ext
7582 < LIBS=$ac_check_lib_save_LIBS
7583 < fi
7584 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
7585 < $as_echo "$ac_cv_lib_m_asin" >&6; }
7586 < if test $ac_cv_lib_m_asin = yes; then
7587 <  cat >>confdefs.h <<_ACEOF
7588 < #define HAVE_LIBM 1
7589 < _ACEOF
7590 <
7591 <  LIBS="-lm $LIBS"
7592 <
7593 < else
7594 <  exit
7595 < fi
7596 <
7597 <
7598 < { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7599 < $as_echo_n "checking for ANSI C header files... " >&6; }
7600 < if test "${ac_cv_header_stdc+set}" = set; then
7601 <  $as_echo_n "(cached) " >&6
7602 < else
7603 <  cat >conftest.$ac_ext <<_ACEOF
7604 < /* confdefs.h.  */
7605 < _ACEOF
7606 < cat confdefs.h >>conftest.$ac_ext
7607 < cat >>conftest.$ac_ext <<_ACEOF
7608 < /* end confdefs.h.  */
7609 < #include <stdlib.h>
7610 < #include <stdarg.h>
7611 < #include <string.h>
7612 < #include <float.h>
7613 <
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
7622 < int
7623 < main ()
7624 < {
7625 <
7626 <  ;
7627 <  return 0;
7628 < }
7629 < _ACEOF
7630 < 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
7648 <  ac_cv_header_stdc=yes
7649 < else
7650 <  $as_echo "$as_me: failed program was:" >&5
7651 < sed 's/^/| /' conftest.$ac_ext >&5
7652 <
7653 <        ac_cv_header_stdc=no
7654 < fi
7655 <
7656 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7657 <
7658 < if test $ac_cv_header_stdc = yes; then
7659 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7660 <  cat >conftest.$ac_ext <<_ACEOF
7661 < /* confdefs.h.  */
7662 < _ACEOF
7663 < cat confdefs.h >>conftest.$ac_ext
7664 < cat >>conftest.$ac_ext <<_ACEOF
7665 < /* end confdefs.h.  */
7666 < #include <string.h>
7667 <
7668 < _ACEOF
7669 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7670 <  $EGREP "memchr" >/dev/null 2>&1; then
7671 <  :
7672 < else
7673 <  ac_cv_header_stdc=no
7674 < fi
7675 < rm -f conftest*
7676 <
7677 < fi
7678 <
7679 < if test $ac_cv_header_stdc = yes; then
7680 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7681 <  cat >conftest.$ac_ext <<_ACEOF
7682 < /* confdefs.h.  */
7683 < _ACEOF
7684 < cat confdefs.h >>conftest.$ac_ext
7685 < cat >>conftest.$ac_ext <<_ACEOF
7686 < /* end confdefs.h.  */
7687 < #include <stdlib.h>
7688 <
7689 < _ACEOF
7690 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7691 <  $EGREP "free" >/dev/null 2>&1; then
7692 <  :
7693 < else
7694 <  ac_cv_header_stdc=no
7695 < fi
7696 < rm -f conftest*
7697 <
7698 < fi
7699 <
7700 < if test $ac_cv_header_stdc = yes; then
7701 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7702 <  if test "$cross_compiling" = yes; then
7703 <  :
7704 < else
7705 <  cat >conftest.$ac_ext <<_ACEOF
7706 < /* confdefs.h.  */
7707 < _ACEOF
7708 < cat confdefs.h >>conftest.$ac_ext
7709 < cat >>conftest.$ac_ext <<_ACEOF
7710 < /* end confdefs.h.  */
7711 < #include <ctype.h>
7712 < #include <stdlib.h>
7713 < #if ((' ' & 0x0FF) == 0x020)
7714 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7715 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7716 < #else
7717 < # define ISLOWER(c) \
7718 <                   (('a' <= (c) && (c) <= 'i') \
7719 <                     || ('j' <= (c) && (c) <= 'r') \
7720 <                     || ('s' <= (c) && (c) <= 'z'))
7721 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7722 < #endif
7723 <
7724 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7725 < int
7726 < main ()
7727 < {
7728 <  int i;
7729 <  for (i = 0; i < 256; i++)
7730 <    if (XOR (islower (i), ISLOWER (i))
7731 <        || toupper (i) != TOUPPER (i))
7732 <      return 2;
7733 <  return 0;
7734 < }
7735 < _ACEOF
7736 < 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
7763 <
7764 < ( exit $ac_status )
7765 < ac_cv_header_stdc=no
7766 < fi
7767 < rm -rf conftest.dSYM
7768 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7769 < fi
7770 <
7771 <
7772 < fi
7773 < fi
7774 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7775 < $as_echo "$ac_cv_header_stdc" >&6; }
7776 < if test $ac_cv_header_stdc = yes; then
7777 <
7778 < cat >>confdefs.h <<\_ACEOF
7779 < #define STDC_HEADERS 1
7780 < _ACEOF
7781 <
7782 < fi
7783 <
7784 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
7785 <
7786 <
7787 <
7788 <
7789 <
7790 <
7791 <
7792 <
7793 <
7794 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
7795 <                  inttypes.h stdint.h unistd.h
7796 < do
7797 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
7798 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
7799 < $as_echo_n "checking for $ac_header... " >&6; }
7800 < 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
7847 <  cat >>confdefs.h <<_ACEOF
7848 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
7849 < _ACEOF
7850 <
7851 < fi
7852 <
7853 < done
7854 <
7855 <
7856 < #
7857 < # Handle user hints
7858 < #
7859 <
7860 < # Check whether --with-zlib was given.
7861 < if test "${with_zlib+set}" = set; then
7862 <  withval=$with_zlib; zlib_dir="$withval"
7863 < else
7864 <                zlib_dir="not_set"
7865 < fi
7866 <
7867 < if test "$zlib_dir" != "no"; then
7868 <
7869 < if test "$zlib_dir" != "not_set" ; then
7870 <  if test -d "$zlib_dir"
7871 <  then
7872 <    ZLIB_HOME="$zlib_dir"
7873 <  else
7874 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
7875 < $as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
7876 <        ZLIB_HOME=/usr/local
7877 <        if test ! -f "${ZLIB_HOME}/include/zlib.h"
7878 <        then
7879 <                ZLIB_HOME=/usr
7880 <        fi
7881 <  fi
7882 < fi
7883 < #
7884 < # Locate zlib, if wanted
7885 < #
7886 < if test -n "${ZLIB_HOME}"
7887 < then
7888 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
7889 <        ZLIB_OLD_CFLAGS=$CFLAGS
7890 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
7891 <        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
7892 <
7893 <        ac_ext=c
7894 < ac_cpp='$CPP $CPPFLAGS'
7895 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7896 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7897 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7898 <
7899 <        { $as_echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
7900 < $as_echo_n "checking for inflateEnd in -lz... " >&6; }
7901 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
7902 <  $as_echo_n "(cached) " >&6
7903 < else
7904 <  ac_check_lib_save_LIBS=$LIBS
7905 < LIBS="-lz  $LIBS"
7906 < cat >conftest.$ac_ext <<_ACEOF
7907 < /* confdefs.h.  */
7908 < _ACEOF
7909 < cat confdefs.h >>conftest.$ac_ext
7910 < cat >>conftest.$ac_ext <<_ACEOF
7911 < /* end confdefs.h.  */
7912 <
7913 < /* Override any GCC internal prototype to avoid an error.
7914 <   Use char because int might match the return type of a GCC
7915 <   builtin and then its argument prototype would still apply.  */
7916 < #ifdef __cplusplus
7917 < extern "C"
7918 < #endif
7919 < 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
7928 < int
7929 < main ()
7930 < {
7931 < return inflateEnd ();
7932 <  ;
7933 <  return 0;
7934 < }
7935 < _ACEOF
7936 < 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
7957 <  ac_cv_lib_z_inflateEnd=yes
7958 < else
7959 <  $as_echo "$as_me: failed program was:" >&5
7960 < sed 's/^/| /' conftest.$ac_ext >&5
7961 <
7962 <        ac_cv_lib_z_inflateEnd=no
7963 < fi
7964 <
7965 < rm -rf conftest.dSYM
7966 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7967 <      conftest$ac_exeext conftest.$ac_ext
7968 < LIBS=$ac_check_lib_save_LIBS
7969 < fi
7970 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7971 < $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
7972 < if test $ac_cv_lib_z_inflateEnd = yes; then
7973 <  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; }
7986 < else
7987 <  # Is the header compilable?
7988 < { $as_echo "$as_me:$LINENO: checking zlib.h usability" >&5
7989 < $as_echo_n "checking zlib.h usability... " >&6; }
7990 < cat >conftest.$ac_ext <<_ACEOF
7991 < /* confdefs.h.  */
7992 < _ACEOF
7993 < cat confdefs.h >>conftest.$ac_ext
7994 < cat >>conftest.$ac_ext <<_ACEOF
7995 < /* end confdefs.h.  */
7996 < $ac_includes_default
7997 < #include <zlib.h>
7998 < _ACEOF
7999 < rm -f conftest.$ac_objext
8000 < if { (ac_try="$ac_compile"
8001 < case "(($ac_try" in
8002 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8003 <  *) ac_try_echo=$ac_try;;
8004 < esac
8005 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8006 < $as_echo "$ac_try_echo") >&5
8007 <  (eval "$ac_compile") 2>conftest.er1
8008 <  ac_status=$?
8009 <  grep -v '^ *+' conftest.er1 >conftest.err
8010 <  rm -f conftest.er1
8011 <  cat conftest.err >&5
8012 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8013 <  (exit $ac_status); } && {
8014 <         test -z "$ac_c_werror_flag" ||
8015 <         test ! -s conftest.err
8016 <       } && test -s conftest.$ac_objext; then
8017 <  ac_header_compiler=yes
8018 < else
8019 <  $as_echo "$as_me: failed program was:" >&5
8020 < sed 's/^/| /' conftest.$ac_ext >&5
8021 <
8022 <        ac_header_compiler=no
8023 < fi
8024 <
8025 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8026 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8027 < $as_echo "$ac_header_compiler" >&6; }
8028 <
8029 < # Is the header present?
8030 < { $as_echo "$as_me:$LINENO: checking zlib.h presence" >&5
8031 < $as_echo_n "checking zlib.h presence... " >&6; }
8032 < cat >conftest.$ac_ext <<_ACEOF
8033 < /* confdefs.h.  */
8034 < _ACEOF
8035 < cat confdefs.h >>conftest.$ac_ext
8036 < cat >>conftest.$ac_ext <<_ACEOF
8037 < /* end confdefs.h.  */
8038 < #include <zlib.h>
8039 < _ACEOF
8040 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8041 < case "(($ac_try" in
8042 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8043 <  *) ac_try_echo=$ac_try;;
8044 < esac
8045 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8046 < $as_echo "$ac_try_echo") >&5
8047 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8048 <  ac_status=$?
8049 <  grep -v '^ *+' conftest.er1 >conftest.err
8050 <  rm -f conftest.er1
8051 <  cat conftest.err >&5
8052 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8053 <  (exit $ac_status); } >/dev/null && {
8054 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8055 <         test ! -s conftest.err
8056 <       }; then
8057 <  ac_header_preproc=yes
8058 < else
8059 <  $as_echo "$as_me: failed program was:" >&5
8060 < sed 's/^/| /' conftest.$ac_ext >&5
8061 <
8062 <  ac_header_preproc=no
8063 < fi
8064 <
8065 < rm -f conftest.err conftest.$ac_ext
8066 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8067 < $as_echo "$ac_header_preproc" >&6; }
8068 <
8069 < # So?  What about this header?
8070 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8071 <  yes:no: )
8072 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
8073 < $as_echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8074 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
8075 < $as_echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
8076 <    ac_header_preproc=yes
8077 <    ;;
8078 <  no:yes:* )
8079 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
8080 < $as_echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
8081 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
8082 < $as_echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
8083 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
8084 < $as_echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
8085 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
8086 < $as_echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8087 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
8088 < $as_echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
8089 <    { $as_echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
8090 < $as_echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
8091 <    ( cat <<\_ASBOX
8092 < ## ------------------------------ ##
8093 < ## Report this to gezelter@nd.edu ##
8094 < ## ------------------------------ ##
8095 < _ASBOX
8096 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8097 <    ;;
8098 < esac
8099 < { $as_echo "$as_me:$LINENO: checking for zlib.h" >&5
8100 < $as_echo_n "checking for zlib.h... " >&6; }
8101 < if test "${ac_cv_header_zlib_h+set}" = set; then
8102 <  $as_echo_n "(cached) " >&6
8103 < else
8104 <  ac_cv_header_zlib_h=$ac_header_preproc
8105 < fi
8106 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
8107 < $as_echo "$ac_cv_header_zlib_h" >&6; }
8108 <
8109 < fi
8110 < if test $ac_cv_header_zlib_h = yes; then
8111 <  zlib_cv_zlib_h=yes
8112 < else
8113 <  zlib_cv_zlib_h=no
8114 < fi
8115 <
8116 <
8117 <        ac_ext=c
8118 < ac_cpp='$CPP $CPPFLAGS'
8119 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8120 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8121 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8122 <
8123 <
8124 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
8125 <
8126 < cat >>confdefs.h <<\_ACEOF
8127 < #define HAVE_ZLIB_H 1
8128 < _ACEOF
8129 <
8130 <
8131 < cat >>confdefs.h <<\_ACEOF
8132 < #define HAVE_LIBZ 1
8133 < _ACEOF
8134 <
8135 <                ZLIB_INC_DIR="${ZLIB_HOME}/include"
8136 <                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
8137 <                ZLIB="-lz"
8138 <        else
8139 <                { $as_echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
8140 < $as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
8141 <                ZLIB_INC_DIR=
8142 <                ZLIB_LIB_DIR=
8143 <                ZLIB=
8144 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
8145 <                CFLAGS="$ZLIB_OLD_CFLAGS"
8146 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
8147 < $as_echo "failed" >&6; }
8148 <                echo ""
8149 <                echo "*********************************************************"
8150 <                echo "* WARNING: Could not find a working zlib installation   *"
8151 <                echo "* If you need OOPSE to be able to deal with compressed  *"
8152 <                echo "* trajectory dump files be sure to specify a valid zlib *"
8153 <                echo "* installation with --with-zlib=DIR                     *"
8154 <                echo "*                                                       *"
8155 <                echo "* OOPSE will still work without zlib installed.         *"
8156 <                echo "*********************************************************"
8157 <                echo ""
8158 <        fi
8159 <
8160 <
8161 <
8162 < fi
8163 < fi
8164 <
8165 < #
8166 < # Handle user hints
8167 < #
8168 <
8169 < # Check whether --with-fftw was given.
8170 < if test "${with_fftw+set}" = set; then
8171 <  withval=$with_fftw; fftw_dir="$withval"
8172 < else
8173 <             fftw_dir="not_set"
8174 < fi
8175 <
8176 < if test "$fftw_dir" != "no"; then
8177 <  if test "$fftw_dir" != "not_set" ; then
8178 <    if test -d "$fftw_dir"; then
8179 <      FFTW_HOME="$fftw_dir"
8180 <    else
8181 <      { $as_echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
8182 < $as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
8183 <      FFTW_HOME=/usr/local
8184 <      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
8185 <        FFTW_HOME=/usr
8186 <      fi
8187 <    fi
8188 <    #
8189 <    # Locate fftw, if wanted
8190 <    #
8191 <    if test -n "${FFTW_HOME}"; then
8192 <      FFTW_OLD_LDFLAGS=$LDFLAGS
8193 <      FFTW_OLD_CFLAGS=$CFLAGS
8194 <      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
8195 <      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
8196 <
8197 <      ac_ext=c
8198 < ac_cpp='$CPP $CPPFLAGS'
8199 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8200 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8201 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8202 <
8203 <      { $as_echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
8204 < $as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
8205 < if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
8206 <  $as_echo_n "(cached) " >&6
8207 < else
8208 <  ac_check_lib_save_LIBS=$LIBS
8209 < LIBS="-lfftw3  $LIBS"
8210 < cat >conftest.$ac_ext <<_ACEOF
8211 < /* confdefs.h.  */
8212 < _ACEOF
8213 < cat confdefs.h >>conftest.$ac_ext
8214 < cat >>conftest.$ac_ext <<_ACEOF
8215 < /* end confdefs.h.  */
8216 <
8217 < /* Override any GCC internal prototype to avoid an error.
8218 <   Use char because int might match the return type of a GCC
8219 <   builtin and then its argument prototype would still apply.  */
8220 < #ifdef __cplusplus
8221 < extern "C"
8222 < #endif
8223 < 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
8232 < int
8233 < main ()
8234 < {
8235 < return fftw_execute ();
8236 <  ;
8237 <  return 0;
8238 < }
8239 < _ACEOF
8240 < 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
8261 <  ac_cv_lib_fftw3_fftw_execute=yes
8262 < else
8263 <  $as_echo "$as_me: failed program was:" >&5
8264 < sed 's/^/| /' conftest.$ac_ext >&5
8265 <
8266 <        ac_cv_lib_fftw3_fftw_execute=no
8267 < fi
8268 <
8269 < rm -rf conftest.dSYM
8270 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8271 <      conftest$ac_exeext conftest.$ac_ext
8272 < LIBS=$ac_check_lib_save_LIBS
8273 < fi
8274 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
8275 < $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
8276 < if test $ac_cv_lib_fftw3_fftw_execute = yes; then
8277 <  fftw_cv_libfftw3=yes
8278 < else
8279 <  fftw_cv_libfftw3=no
8280 < fi
8281 <
8282 <      if test "${ac_cv_header_fftw3_h+set}" = set; then
8283 <  { $as_echo "$as_me:$LINENO: checking for fftw3.h" >&5
8284 < $as_echo_n "checking for fftw3.h... " >&6; }
8285 < if test "${ac_cv_header_fftw3_h+set}" = set; then
8286 <  $as_echo_n "(cached) " >&6
8287 < fi
8288 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8289 < $as_echo "$ac_cv_header_fftw3_h" >&6; }
8290 < else
8291 <  # Is the header compilable?
8292 < { $as_echo "$as_me:$LINENO: checking fftw3.h usability" >&5
8293 < $as_echo_n "checking fftw3.h usability... " >&6; }
8294 < cat >conftest.$ac_ext <<_ACEOF
8295 < /* confdefs.h.  */
8296 < _ACEOF
8297 < cat confdefs.h >>conftest.$ac_ext
8298 < cat >>conftest.$ac_ext <<_ACEOF
8299 < /* end confdefs.h.  */
8300 < $ac_includes_default
8301 < #include <fftw3.h>
8302 < _ACEOF
8303 < rm -f conftest.$ac_objext
8304 < if { (ac_try="$ac_compile"
8305 < case "(($ac_try" in
8306 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8307 <  *) ac_try_echo=$ac_try;;
8308 < esac
8309 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8310 < $as_echo "$ac_try_echo") >&5
8311 <  (eval "$ac_compile") 2>conftest.er1
8312 <  ac_status=$?
8313 <  grep -v '^ *+' conftest.er1 >conftest.err
8314 <  rm -f conftest.er1
8315 <  cat conftest.err >&5
8316 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8317 <  (exit $ac_status); } && {
8318 <         test -z "$ac_c_werror_flag" ||
8319 <         test ! -s conftest.err
8320 <       } && test -s conftest.$ac_objext; then
8321 <  ac_header_compiler=yes
8322 < else
8323 <  $as_echo "$as_me: failed program was:" >&5
8324 < sed 's/^/| /' conftest.$ac_ext >&5
8325 <
8326 <        ac_header_compiler=no
8327 < fi
8328 <
8329 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8330 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8331 < $as_echo "$ac_header_compiler" >&6; }
8332 <
8333 < # Is the header present?
8334 < { $as_echo "$as_me:$LINENO: checking fftw3.h presence" >&5
8335 < $as_echo_n "checking fftw3.h presence... " >&6; }
8336 < cat >conftest.$ac_ext <<_ACEOF
8337 < /* confdefs.h.  */
8338 < _ACEOF
8339 < cat confdefs.h >>conftest.$ac_ext
8340 < cat >>conftest.$ac_ext <<_ACEOF
8341 < /* end confdefs.h.  */
8342 < #include <fftw3.h>
8343 < _ACEOF
8344 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8345 < case "(($ac_try" in
8346 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8347 <  *) ac_try_echo=$ac_try;;
8348 < esac
8349 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8350 < $as_echo "$ac_try_echo") >&5
8351 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8352 <  ac_status=$?
8353 <  grep -v '^ *+' conftest.er1 >conftest.err
8354 <  rm -f conftest.er1
8355 <  cat conftest.err >&5
8356 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
8357 <  (exit $ac_status); } >/dev/null && {
8358 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8359 <         test ! -s conftest.err
8360 <       }; then
8361 <  ac_header_preproc=yes
8362 < else
8363 <  $as_echo "$as_me: failed program was:" >&5
8364 < sed 's/^/| /' conftest.$ac_ext >&5
8365 <
8366 <  ac_header_preproc=no
8367 < fi
8368 <
8369 < rm -f conftest.err conftest.$ac_ext
8370 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8371 < $as_echo "$ac_header_preproc" >&6; }
8372 <
8373 < # So?  What about this header?
8374 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8375 <  yes:no: )
8376 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
8377 < $as_echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8378 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
8379 < $as_echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
8380 <    ac_header_preproc=yes
8381 <    ;;
8382 <  no:yes:* )
8383 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
8384 < $as_echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
8385 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
8386 < $as_echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
8387 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
8388 < $as_echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
8389 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
8390 < $as_echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8391 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
8392 < $as_echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
8393 <    { $as_echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
8394 < $as_echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
8395 <    ( cat <<\_ASBOX
8396 < ## ------------------------------ ##
8397 < ## Report this to gezelter@nd.edu ##
8398 < ## ------------------------------ ##
8399 < _ASBOX
8400 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8401 <    ;;
8402 < esac
8403 < { $as_echo "$as_me:$LINENO: checking for fftw3.h" >&5
8404 < $as_echo_n "checking for fftw3.h... " >&6; }
8405 < if test "${ac_cv_header_fftw3_h+set}" = set; then
8406 <  $as_echo_n "(cached) " >&6
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
8415 <  fftw_cv_fftw3_h=yes
8416 < else
8417 <  fftw_cv_fftw3_h=no
8418 < fi
8419 <
8420 <
8421 <      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
8422 <        { $as_echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
8423 < $as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
8424 < if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
8425 <  $as_echo_n "(cached) " >&6
8426 < else
8427 <  ac_check_lib_save_LIBS=$LIBS
8428 < LIBS="-lfftw  $LIBS"
8429 < cat >conftest.$ac_ext <<_ACEOF
8430 < /* confdefs.h.  */
8431 < _ACEOF
8432 < cat confdefs.h >>conftest.$ac_ext
8433 < cat >>conftest.$ac_ext <<_ACEOF
8434 < /* end confdefs.h.  */
8435 <
8436 < /* Override any GCC internal prototype to avoid an error.
8437 <   Use char because int might match the return type of a GCC
8438 <   builtin and then its argument prototype would still apply.  */
8439 < #ifdef __cplusplus
8440 < extern "C"
8441 < #endif
8442 < 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
8451 < int
8452 < main ()
8453 < {
8454 < return fftwnd_one ();
8455 <  ;
8456 <  return 0;
8457 < }
8458 < _ACEOF
8459 < 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
8480 <  ac_cv_lib_fftw_fftwnd_one=yes
8481 < else
8482 <  $as_echo "$as_me: failed program was:" >&5
8483 < sed 's/^/| /' conftest.$ac_ext >&5
8484 <
8485 <        ac_cv_lib_fftw_fftwnd_one=no
8486 < fi
8487 <
8488 < rm -rf conftest.dSYM
8489 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8490 <      conftest$ac_exeext conftest.$ac_ext
8491 < LIBS=$ac_check_lib_save_LIBS
8492 < fi
8493 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
8494 < $as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
8495 < if test $ac_cv_lib_fftw_fftwnd_one = yes; then
8496 <  fftw_cv_libfftw=yes
8497 < else
8498 <  fftw_cv_libfftw=no
8499 < fi
8500 <
8501 <        if test "${ac_cv_header_fftw_h+set}" = set; then
8502 <  { $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
8634 <  fftw_cv_fftw_h=yes
8635 < else
8636 <  fftw_cv_fftw_h=no
8637 < fi
8638 <
8639 <
8640 <        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
8641 <          { $as_echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
8642 < $as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
8643 < if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
8644 <  $as_echo_n "(cached) " >&6
8645 < else
8646 <  ac_check_lib_save_LIBS=$LIBS
8647 < LIBS="-ldfftw  $LIBS"
8648 < cat >conftest.$ac_ext <<_ACEOF
8649 < /* confdefs.h.  */
8650 < _ACEOF
8651 < cat confdefs.h >>conftest.$ac_ext
8652 < cat >>conftest.$ac_ext <<_ACEOF
8653 < /* end confdefs.h.  */
8654 <
8655 < /* Override any GCC internal prototype to avoid an error.
8656 <   Use char because int might match the return type of a GCC
8657 <   builtin and then its argument prototype would still apply.  */
8658 < #ifdef __cplusplus
8659 < extern "C"
8660 < #endif
8661 < 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
8670 < int
8671 < main ()
8672 < {
8673 < return fftwnd_one ();
8674 <  ;
8675 <  return 0;
8676 < }
8677 < _ACEOF
8678 < 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
8699 <  ac_cv_lib_dfftw_fftwnd_one=yes
8700 < else
8701 <  $as_echo "$as_me: failed program was:" >&5
8702 < sed 's/^/| /' conftest.$ac_ext >&5
8703 <
8704 <        ac_cv_lib_dfftw_fftwnd_one=no
8705 < fi
8706 <
8707 < rm -rf conftest.dSYM
8708 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8709 <      conftest$ac_exeext conftest.$ac_ext
8710 < LIBS=$ac_check_lib_save_LIBS
8711 < fi
8712 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
8713 < $as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
8714 < if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
8715 <  fftw_cv_libdfftw=yes
8716 < else
8717 <  fftw_cv_libdfftw=no
8718 < fi
8719 <
8720 <          if test "${ac_cv_header_dfftw_h+set}" = set; then
8721 <  { $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
8853 <  fftw_cv_dfftw_h=yes
8854 < else
8855 <  fftw_cv_dfftw_h=no
8856 < fi
8857 <
8858 <
8859 <        fi
8860 <      fi
8861 <      ac_ext=c
8862 < ac_cpp='$CPP $CPPFLAGS'
8863 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8864 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8865 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8866 <
8867 <      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
8868 <
8869 < cat >>confdefs.h <<\_ACEOF
8870 < #define HAVE_FFTW3_H 1
8871 < _ACEOF
8872 <
8873 <        FFTW_INC_DIR="${FFTW_HOME}/include"
8874 <        FFTW_LIB_DIR="${FFTW_HOME}/lib"
8875 <        FFTW_LIBS="-lfftw3"
8876 <      else
8877 <        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
8878 <
8879 < cat >>confdefs.h <<\_ACEOF
8880 < #define HAVE_FFTW_H 1
8881 < _ACEOF
8882 <
8883 <          FFTW_INC_DIR="${FFTW_HOME}/include"
8884 <          FFTW_LIB_DIR="${FFTW_HOME}/lib"
8885 <          FFTW_LIBS="-lfftw"
8886 <        else
8887 <          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
8888 <
8889 < cat >>confdefs.h <<\_ACEOF
8890 < #define HAVE_DFFTW_H 1
8891 < _ACEOF
8892 <
8893 <            FFTW_INC_DIR="${FFTW_HOME}/include"
8894 <            FFTW_LIB_DIR="${FFTW_HOME}/lib"
8895 <            FFTW_LIBS="-ldfftw"
8896 <          else
8897 <            { $as_echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
8898 < $as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
8899 <            FFTW_INC_DIR=
8900 <            FFTW_LIB_DIR=
8901 <            FFTW_LIBS=
8902 <            LDFLAGS="$FFTW_OLD_LDFLAGS"
8903 <            CFLAGS="$FFTW_OLD_CFLAGS"
8904 <            { $as_echo "$as_me:$LINENO: result: failed" >&5
8905 < $as_echo "failed" >&6; }
8906 <            echo ""
8907 <            echo "*********************************************************"
8908 <            echo "* WARNING: Could not find a working FFTW installation   *"
8909 <            echo "* If you need the staticProps program to be able to     *"
8910 <            echo "* compute undulation spectra, be sure to specify a      *"
8911 <            echo "* valid fftw installation with --with-fftw=DIR          *"
8912 <            echo "*                                                       *"
8913 <            echo "* OOPSE will still work without fftw installed.         *"
8914 <            echo "*********************************************************"
8915 <            echo ""
8916 <          fi
8917 <        fi
8918 <      fi
8919 <
8920 <
8921 <
8922 <    fi
8923 <  fi
8924 < fi
8925 <
8926 < #
8927 < # Handle user hints
8928 < #
8929 <
8930 < # Check whether --with-qhull was given.
8931 < if test "${with_qhull+set}" = set; then
8932 <  withval=$with_qhull; qhull_dir="$withval"
8933 < else
8934 <                qhull_dir="not_set"
8935 < fi
8936 <
8937 < if test "$qhull_dir" != "no"; then
8938 <
8939 < if test "$qhull_dir" != "not_set" ; then
8940 <  if test -d "$qhull_dir"
8941 <  then
8942 <    QHULL_HOME="$qhull_dir"
8943 <  else
8944 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
8945 < $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
8946 <        QHULL_HOME=/usr/local
8947 <        if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"
8948 <        then
8949 <                QHULL_HOME=/usr
8950 <        fi
8951 <  fi
8952 < fi
8953 < #
8954 < # Locate qhull, if wanted
8955 < #
8956 < if test -n "${QHULL_HOME}"
8957 < then
8958 <
8959 <        ac_ext=c
8960 < ac_cpp='$CPP $CPPFLAGS'
8961 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8962 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8963 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8964 <
8965 <        QHULL_OLD_LDFLAGS=$LDFLAGS
8966 <        QHULL_OLD_CFLAGS=$CFLAGS
8967 <        QHULL_OLD_CPPFLAGS=$CPPFLAGS
8968 <        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
8969 <        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
8970 <        CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
8971 <        if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8972 <  { $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
8973 < $as_echo_n "checking for qhull/qhull.h... " >&6; }
8974 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8975 <  $as_echo_n "(cached) " >&6
8976 < fi
8977 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
8978 < $as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
8979 < else
8980 <  # Is the header compilable?
8981 < { $as_echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
8982 < $as_echo_n "checking qhull/qhull.h usability... " >&6; }
8983 < cat >conftest.$ac_ext <<_ACEOF
8984 < /* confdefs.h.  */
8985 < _ACEOF
8986 < cat confdefs.h >>conftest.$ac_ext
8987 < cat >>conftest.$ac_ext <<_ACEOF
8988 < /* end confdefs.h.  */
8989 < $ac_includes_default
8990 < #include <qhull/qhull.h>
8991 < _ACEOF
8992 < rm -f conftest.$ac_objext
8993 < if { (ac_try="$ac_compile"
8994 < case "(($ac_try" in
8995 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8996 <  *) ac_try_echo=$ac_try;;
8997 < esac
8998 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
8999 < $as_echo "$ac_try_echo") >&5
9000 <  (eval "$ac_compile") 2>conftest.er1
9001 <  ac_status=$?
9002 <  grep -v '^ *+' conftest.er1 >conftest.err
9003 <  rm -f conftest.er1
9004 <  cat conftest.err >&5
9005 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9006 <  (exit $ac_status); } && {
9007 <         test -z "$ac_c_werror_flag" ||
9008 <         test ! -s conftest.err
9009 <       } && test -s conftest.$ac_objext; then
9010 <  ac_header_compiler=yes
9011 < else
9012 <  $as_echo "$as_me: failed program was:" >&5
9013 < sed 's/^/| /' conftest.$ac_ext >&5
9014 <
9015 <        ac_header_compiler=no
9016 < fi
9017 <
9018 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9019 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9020 < $as_echo "$ac_header_compiler" >&6; }
9021 <
9022 < # Is the header present?
9023 < { $as_echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
9024 < $as_echo_n "checking qhull/qhull.h presence... " >&6; }
9025 < cat >conftest.$ac_ext <<_ACEOF
9026 < /* confdefs.h.  */
9027 < _ACEOF
9028 < cat confdefs.h >>conftest.$ac_ext
9029 < cat >>conftest.$ac_ext <<_ACEOF
9030 < /* end confdefs.h.  */
9031 < #include <qhull/qhull.h>
9032 < _ACEOF
9033 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9034 < case "(($ac_try" in
9035 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9036 <  *) ac_try_echo=$ac_try;;
9037 < esac
9038 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9039 < $as_echo "$ac_try_echo") >&5
9040 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9041 <  ac_status=$?
9042 <  grep -v '^ *+' conftest.er1 >conftest.err
9043 <  rm -f conftest.er1
9044 <  cat conftest.err >&5
9045 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9046 <  (exit $ac_status); } >/dev/null && {
9047 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
9048 <         test ! -s conftest.err
9049 <       }; then
9050 <  ac_header_preproc=yes
9051 < else
9052 <  $as_echo "$as_me: failed program was:" >&5
9053 < sed 's/^/| /' conftest.$ac_ext >&5
9054 <
9055 <  ac_header_preproc=no
9056 < fi
9057 <
9058 < rm -f conftest.err conftest.$ac_ext
9059 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9060 < $as_echo "$ac_header_preproc" >&6; }
9061 <
9062 < # So?  What about this header?
9063 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9064 <  yes:no: )
9065 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
9066 < $as_echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9067 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
9068 < $as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
9069 <    ac_header_preproc=yes
9070 <    ;;
9071 <  no:yes:* )
9072 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
9073 < $as_echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
9074 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&5
9075 < $as_echo "$as_me: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&2;}
9076 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
9077 < $as_echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
9078 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&5
9079 < $as_echo "$as_me: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9080 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
9081 < $as_echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
9082 <    { $as_echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
9083 < $as_echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
9084 <    ( cat <<\_ASBOX
9085 < ## ------------------------------ ##
9086 < ## Report this to gezelter@nd.edu ##
9087 < ## ------------------------------ ##
9088 < _ASBOX
9089 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9090 <    ;;
9091 < esac
9092 < { $as_echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
9093 < $as_echo_n "checking for qhull/qhull.h... " >&6; }
9094 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
9095 <  $as_echo_n "(cached) " >&6
9096 < else
9097 <  ac_cv_header_qhull_qhull_h=$ac_header_preproc
9098 < fi
9099 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
9100 < $as_echo "$ac_cv_header_qhull_qhull_h" >&6; }
9101 <
9102 < fi
9103 < if test $ac_cv_header_qhull_qhull_h = yes; then
9104 <  qhull_cv_qhull_h=yes
9105 < else
9106 <  qhull_cv_qhull_h=no
9107 < fi
9108 <
9109 <
9110 <        { $as_echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
9111 < $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
9112 < if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
9113 <  $as_echo_n "(cached) " >&6
9114 < else
9115 <  ac_check_lib_save_LIBS=$LIBS
9116 < LIBS="-lqhull  $LIBS"
9117 < cat >conftest.$ac_ext <<_ACEOF
9118 < /* confdefs.h.  */
9119 < _ACEOF
9120 < cat confdefs.h >>conftest.$ac_ext
9121 < cat >>conftest.$ac_ext <<_ACEOF
9122 < /* end confdefs.h.  */
9123 <
9124 < /* Override any GCC internal prototype to avoid an error.
9125 <   Use char because int might match the return type of a GCC
9126 <   builtin and then its argument prototype would still apply.  */
9127 < #ifdef __cplusplus
9128 < extern "C"
9129 < #endif
9130 < char qh_qhull ();
9131 < #ifdef FC_DUMMY_MAIN
9132 < #ifndef FC_DUMMY_MAIN_EQ_F77
9133 < #  ifdef __cplusplus
9134 <     extern "C"
9135 < #  endif
9136 <   int FC_DUMMY_MAIN() { return 1; }
9137 < #endif
9138 < #endif
9139 < int
9140 < main ()
9141 < {
9142 < return qh_qhull ();
9143 <  ;
9144 <  return 0;
9145 < }
9146 < _ACEOF
9147 < rm -f conftest.$ac_objext conftest$ac_exeext
9148 < if { (ac_try="$ac_link"
9149 < case "(($ac_try" in
9150 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9151 <  *) ac_try_echo=$ac_try;;
9152 < esac
9153 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9154 < $as_echo "$ac_try_echo") >&5
9155 <  (eval "$ac_link") 2>conftest.er1
9156 <  ac_status=$?
9157 <  grep -v '^ *+' conftest.er1 >conftest.err
9158 <  rm -f conftest.er1
9159 <  cat conftest.err >&5
9160 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9161 <  (exit $ac_status); } && {
9162 <         test -z "$ac_c_werror_flag" ||
9163 <         test ! -s conftest.err
9164 <       } && test -s conftest$ac_exeext && {
9165 <         test "$cross_compiling" = yes ||
9166 <         $as_test_x conftest$ac_exeext
9167 <       }; then
9168 <  ac_cv_lib_qhull_qh_qhull=yes
9169 < else
9170 <  $as_echo "$as_me: failed program was:" >&5
9171 < sed 's/^/| /' conftest.$ac_ext >&5
9172 <
9173 <        ac_cv_lib_qhull_qh_qhull=no
9174 < fi
9175 <
9176 < rm -rf conftest.dSYM
9177 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9178 <      conftest$ac_exeext conftest.$ac_ext
9179 < LIBS=$ac_check_lib_save_LIBS
9180 < fi
9181 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
9182 < $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
9183 < if test $ac_cv_lib_qhull_qh_qhull = yes; then
9184 <  qhull_cv_libqhull=yes
9185 < else
9186 <  qhull_cv_libqhull=no
9187 < fi
9188 <
9189 <        LDFLAGS="$QHULL_OLD_LDFLAGS"
9190 <        CFLAGS="$QHULL_OLD_CFLAGS"
9191 <        CPPFLAGS="$QHULL_OLD_CPPFLAGS"
9192 <        ac_ext=c
9193 < ac_cpp='$CPP $CPPFLAGS'
9194 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9195 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9196 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9197 <
9198 <
9199 <        if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
9200 <
9201 < cat >>confdefs.h <<\_ACEOF
9202 < #define HAVE_QHULL_H 1
9203 < _ACEOF
9204 <
9205 <
9206 < cat >>confdefs.h <<\_ACEOF
9207 < #define HAVE_QHULL 1
9208 < _ACEOF
9209 <
9210 <                USE_QHULL=yes
9211 <                QHULL_INC_DIR="${QHULL_HOME}/include"
9212 <                QHULL_LIB_DIR="${QHULL_HOME}/lib"
9213 <                QHULL="-lqhull"
9214 <        else
9215 <                { $as_echo "$as_me:$LINENO: checking qhull in ${QHULL_HOME}" >&5
9216 < $as_echo_n "checking qhull in ${QHULL_HOME}... " >&6; }
9217 <                QHULL_INC_DIR=
9218 <                QHULL_LIB_DIR=
9219 <                QHULL=
9220 <                USE_QHULL=no
9221 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
9222 < $as_echo "failed" >&6; }
9223 <                echo ""
9224 <                echo "*********************************************************"
9225 <                echo "* WARNING: Could not find a working qhull installation  *"
9226 <                echo "* If you need OOPSE to be able to deal with convex      *"
9227 <                echo "* hulls be sure to specify a valid qhull installation   *"
9228 <                echo "* with --with-qhull=DIR                                 *"
9229 <                echo "*                                                       *"
9230 <                echo "* OOPSE will still work without qhull installed.        *"
9231 <                echo "*********************************************************"
9232 <                echo ""
9233 <        fi
9234 <
9235 <
9236 <
9237 <
9238 < fi
9239 < fi
9240 <
9241 <
9242 < ac_ext=cpp
9243 < ac_cpp='$CXXCPP $CPPFLAGS'
9244 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9245 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9246 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9247 < { $as_echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
9248 < $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
9249 < if test -z "$CXXCPP"; then
9250 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
9251 <  $as_echo_n "(cached) " >&6
9252 < else
9253 <      # Double quotes because CXXCPP needs to be expanded
9254 <    for CXXCPP in "$CXX -E" "/lib/cpp"
9255 <    do
9256 <      ac_preproc_ok=false
9257 < for ac_cxx_preproc_warn_flag in '' yes
9258 < do
9259 <  # Use a header file that comes with gcc, so configuring glibc
9260 <  # with a fresh cross-compiler works.
9261 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9262 <  # <limits.h> exists even on freestanding compilers.
9263 <  # On the NeXT, cc -E runs the code through the compiler's parser,
9264 <  # not just through cpp. "Syntax error" is here to catch this case.
9265 <  cat >conftest.$ac_ext <<_ACEOF
9266 < /* confdefs.h.  */
9267 < _ACEOF
9268 < cat confdefs.h >>conftest.$ac_ext
9269 < cat >>conftest.$ac_ext <<_ACEOF
9270 < /* end confdefs.h.  */
9271 < #ifdef __STDC__
9272 < # include <limits.h>
9273 < #else
9274 < # include <assert.h>
9275 < #endif
9276 <                     Syntax error
9277 < _ACEOF
9278 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9279 < case "(($ac_try" in
9280 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9281 <  *) ac_try_echo=$ac_try;;
9282 < esac
9283 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9284 < $as_echo "$ac_try_echo") >&5
9285 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9286 <  ac_status=$?
9287 <  grep -v '^ *+' conftest.er1 >conftest.err
9288 <  rm -f conftest.er1
9289 <  cat conftest.err >&5
9290 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9291 <  (exit $ac_status); } >/dev/null && {
9292 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9293 <         test ! -s conftest.err
9294 <       }; then
9295 <  :
9296 < else
9297 <  $as_echo "$as_me: failed program was:" >&5
9298 < sed 's/^/| /' conftest.$ac_ext >&5
9299 <
9300 <  # Broken: fails on valid input.
9301 < continue
9302 < fi
9303 <
9304 < rm -f conftest.err conftest.$ac_ext
9305 <
9306 <  # OK, works on sane cases.  Now check whether nonexistent headers
9307 <  # can be detected and how.
9308 <  cat >conftest.$ac_ext <<_ACEOF
9309 < /* confdefs.h.  */
9310 < _ACEOF
9311 < cat confdefs.h >>conftest.$ac_ext
9312 < cat >>conftest.$ac_ext <<_ACEOF
9313 < /* end confdefs.h.  */
9314 < #include <ac_nonexistent.h>
9315 < _ACEOF
9316 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9317 < case "(($ac_try" in
9318 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9319 <  *) ac_try_echo=$ac_try;;
9320 < esac
9321 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9322 < $as_echo "$ac_try_echo") >&5
9323 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9324 <  ac_status=$?
9325 <  grep -v '^ *+' conftest.er1 >conftest.err
9326 <  rm -f conftest.er1
9327 <  cat conftest.err >&5
9328 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9329 <  (exit $ac_status); } >/dev/null && {
9330 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9331 <         test ! -s conftest.err
9332 <       }; then
9333 <  # Broken: success on invalid input.
9334 < continue
9335 < else
9336 <  $as_echo "$as_me: failed program was:" >&5
9337 < sed 's/^/| /' conftest.$ac_ext >&5
9338 <
9339 <  # Passes both tests.
9340 < ac_preproc_ok=:
9341 < break
9342 < fi
9343 <
9344 < rm -f conftest.err conftest.$ac_ext
9345 <
9346 < done
9347 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9348 < rm -f conftest.err conftest.$ac_ext
9349 < if $ac_preproc_ok; then
9350 <  break
9351 < fi
9352 <
9353 <    done
9354 <    ac_cv_prog_CXXCPP=$CXXCPP
9355 <
9356 < fi
9357 <  CXXCPP=$ac_cv_prog_CXXCPP
9358 < else
9359 <  ac_cv_prog_CXXCPP=$CXXCPP
9360 < fi
9361 < { $as_echo "$as_me:$LINENO: result: $CXXCPP" >&5
9362 < $as_echo "$CXXCPP" >&6; }
9363 < ac_preproc_ok=false
9364 < for ac_cxx_preproc_warn_flag in '' yes
9365 < do
9366 <  # Use a header file that comes with gcc, so configuring glibc
9367 <  # with a fresh cross-compiler works.
9368 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9369 <  # <limits.h> exists even on freestanding compilers.
9370 <  # On the NeXT, cc -E runs the code through the compiler's parser,
9371 <  # not just through cpp. "Syntax error" is here to catch this case.
9372 <  cat >conftest.$ac_ext <<_ACEOF
9373 < /* confdefs.h.  */
9374 < _ACEOF
9375 < cat confdefs.h >>conftest.$ac_ext
9376 < cat >>conftest.$ac_ext <<_ACEOF
9377 < /* end confdefs.h.  */
9378 < #ifdef __STDC__
9379 < # include <limits.h>
9380 < #else
9381 < # include <assert.h>
9382 < #endif
9383 <                     Syntax error
9384 < _ACEOF
9385 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9386 < case "(($ac_try" in
9387 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9388 <  *) ac_try_echo=$ac_try;;
9389 < esac
9390 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9391 < $as_echo "$ac_try_echo") >&5
9392 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9393 <  ac_status=$?
9394 <  grep -v '^ *+' conftest.er1 >conftest.err
9395 <  rm -f conftest.er1
9396 <  cat conftest.err >&5
9397 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9398 <  (exit $ac_status); } >/dev/null && {
9399 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9400 <         test ! -s conftest.err
9401 <       }; then
9402 <  :
9403 < else
9404 <  $as_echo "$as_me: failed program was:" >&5
9405 < sed 's/^/| /' conftest.$ac_ext >&5
9406 <
9407 <  # Broken: fails on valid input.
9408 < continue
9409 < fi
9410 <
9411 < rm -f conftest.err conftest.$ac_ext
9412 <
9413 <  # OK, works on sane cases.  Now check whether nonexistent headers
9414 <  # can be detected and how.
9415 <  cat >conftest.$ac_ext <<_ACEOF
9416 < /* confdefs.h.  */
9417 < _ACEOF
9418 < cat confdefs.h >>conftest.$ac_ext
9419 < cat >>conftest.$ac_ext <<_ACEOF
9420 < /* end confdefs.h.  */
9421 < #include <ac_nonexistent.h>
9422 < _ACEOF
9423 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9424 < case "(($ac_try" in
9425 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9426 <  *) ac_try_echo=$ac_try;;
9427 < esac
9428 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9429 < $as_echo "$ac_try_echo") >&5
9430 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9431 <  ac_status=$?
9432 <  grep -v '^ *+' conftest.er1 >conftest.err
9433 <  rm -f conftest.er1
9434 <  cat conftest.err >&5
9435 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9436 <  (exit $ac_status); } >/dev/null && {
9437 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9438 <         test ! -s conftest.err
9439 <       }; then
9440 <  # Broken: success on invalid input.
9441 < continue
9442 < else
9443 <  $as_echo "$as_me: failed program was:" >&5
9444 < sed 's/^/| /' conftest.$ac_ext >&5
9445 <
9446 <  # Passes both tests.
9447 < ac_preproc_ok=:
9448 < break
9449 < fi
9450 <
9451 < rm -f conftest.err conftest.$ac_ext
9452 <
9453 < done
9454 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9455 < rm -f conftest.err conftest.$ac_ext
9456 < if $ac_preproc_ok; then
9457 <  :
9458 < else
9459 <  { { $as_echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9460 < See \`config.log' for more details." >&5
9461 < $as_echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9462 < See \`config.log' for more details." >&2;}
9463 <   { (exit 1); exit 1; }; }
9464 < fi
9465 <
9466 < ac_ext=cpp
9467 < ac_cpp='$CXXCPP $CPPFLAGS'
9468 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9469 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9470 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9471 <
9472 <
9473 < #
9474 < # Handle user hints
9475 < #
9476 <
9477 < # Check whether --with-openbabel was given.
9478 < if test "${with_openbabel+set}" = set; then
9479 <  withval=$with_openbabel; openbabel_dir="$withval"
9480 < else
9481 <                openbabel_dir="not_set"
9482 < fi
9483 <
9484 < if test "$openbabel_dir" != "no"; then
9485 <
9486 < if test "$openbabel_dir" != "not_set" ; then
9487 <  if test -d "$openbabel_dir"
9488 <  then
9489 <    OPENBABEL_HOME="$openbabel_dir"
9490 <  else
9491 <    { $as_echo "$as_me:$LINENO: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
9492 < $as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
9493 <        OPENBABEL_HOME=/usr/local
9494 <        if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
9495 <        then
9496 <                OPENBABEL_HOME=/usr
9497 <        fi
9498 <  fi
9499 < fi
9500 < #
9501 < # Locate openbabel, if wanted
9502 < #
9503 < if test -n "${OPENBABEL_HOME}"
9504 < then
9505 <
9506 <        ac_ext=cpp
9507 < ac_cpp='$CXXCPP $CPPFLAGS'
9508 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9509 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9510 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9511 <
9512 <        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
9513 <        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
9514 <        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
9515 <        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
9516 <        if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9517 <  { $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9518 < $as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9519 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9520 <  $as_echo_n "(cached) " >&6
9521 < fi
9522 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9523 < $as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9524 < else
9525 <  # Is the header compilable?
9526 < { $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h usability" >&5
9527 < $as_echo_n "checking openbabel/babelconfig.h usability... " >&6; }
9528 < cat >conftest.$ac_ext <<_ACEOF
9529 < /* confdefs.h.  */
9530 < _ACEOF
9531 < cat confdefs.h >>conftest.$ac_ext
9532 < cat >>conftest.$ac_ext <<_ACEOF
9533 < /* end confdefs.h.  */
9534 < $ac_includes_default
9535 < #include <openbabel/babelconfig.h>
9536 < _ACEOF
9537 < rm -f conftest.$ac_objext
9538 < if { (ac_try="$ac_compile"
9539 < case "(($ac_try" in
9540 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9541 <  *) ac_try_echo=$ac_try;;
9542 < esac
9543 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9544 < $as_echo "$ac_try_echo") >&5
9545 <  (eval "$ac_compile") 2>conftest.er1
9546 <  ac_status=$?
9547 <  grep -v '^ *+' conftest.er1 >conftest.err
9548 <  rm -f conftest.er1
9549 <  cat conftest.err >&5
9550 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9551 <  (exit $ac_status); } && {
9552 <         test -z "$ac_cxx_werror_flag" ||
9553 <         test ! -s conftest.err
9554 <       } && test -s conftest.$ac_objext; then
9555 <  ac_header_compiler=yes
9556 < else
9557 <  $as_echo "$as_me: failed program was:" >&5
9558 < sed 's/^/| /' conftest.$ac_ext >&5
9559 <
9560 <        ac_header_compiler=no
9561 < fi
9562 <
9563 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9564 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9565 < $as_echo "$ac_header_compiler" >&6; }
9566 <
9567 < # Is the header present?
9568 < { $as_echo "$as_me:$LINENO: checking openbabel/babelconfig.h presence" >&5
9569 < $as_echo_n "checking openbabel/babelconfig.h presence... " >&6; }
9570 < cat >conftest.$ac_ext <<_ACEOF
9571 < /* confdefs.h.  */
9572 < _ACEOF
9573 < cat confdefs.h >>conftest.$ac_ext
9574 < cat >>conftest.$ac_ext <<_ACEOF
9575 < /* end confdefs.h.  */
9576 < #include <openbabel/babelconfig.h>
9577 < _ACEOF
9578 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9579 < case "(($ac_try" in
9580 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9581 <  *) ac_try_echo=$ac_try;;
9582 < esac
9583 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9584 < $as_echo "$ac_try_echo") >&5
9585 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9586 <  ac_status=$?
9587 <  grep -v '^ *+' conftest.er1 >conftest.err
9588 <  rm -f conftest.er1
9589 <  cat conftest.err >&5
9590 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9591 <  (exit $ac_status); } >/dev/null && {
9592 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9593 <         test ! -s conftest.err
9594 <       }; then
9595 <  ac_header_preproc=yes
9596 < else
9597 <  $as_echo "$as_me: failed program was:" >&5
9598 < sed 's/^/| /' conftest.$ac_ext >&5
9599 <
9600 <  ac_header_preproc=no
9601 < fi
9602 <
9603 < rm -f conftest.err conftest.$ac_ext
9604 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9605 < $as_echo "$ac_header_preproc" >&6; }
9606 <
9607 < # So?  What about this header?
9608 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9609 <  yes:no: )
9610 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5
9611 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9612 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&5
9613 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&2;}
9614 <    ac_header_preproc=yes
9615 <    ;;
9616 <  no:yes:* )
9617 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&5
9618 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&2;}
9619 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&5
9620 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&2;}
9621 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&5
9622 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&2;}
9623 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&5
9624 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9625 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&5
9626 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&2;}
9627 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&5
9628 < $as_echo "$as_me: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&2;}
9629 <    ( cat <<\_ASBOX
9630 < ## ------------------------------ ##
9631 < ## Report this to gezelter@nd.edu ##
9632 < ## ------------------------------ ##
9633 < _ASBOX
9634 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9635 <    ;;
9636 < esac
9637 < { $as_echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9638 < $as_echo_n "checking for openbabel/babelconfig.h... " >&6; }
9639 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9640 <  $as_echo_n "(cached) " >&6
9641 < else
9642 <  ac_cv_header_openbabel_babelconfig_h=$ac_header_preproc
9643 < fi
9644 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9645 < $as_echo "$ac_cv_header_openbabel_babelconfig_h" >&6; }
9646 <
9647 < fi
9648 < if test $ac_cv_header_openbabel_babelconfig_h = yes; then
9649 <  openbabel_cv_openbabel_h=yes
9650 < else
9651 <  openbabel_cv_openbabel_h=no
9652 < fi
9653 <
9654 <
9655 <        if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9656 <  { $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9657 < $as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9658 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9659 <  $as_echo_n "(cached) " >&6
9660 < fi
9661 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9662 < $as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9663 < else
9664 <  # Is the header compilable?
9665 < { $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h usability" >&5
9666 < $as_echo_n "checking openbabel/obconversion.h usability... " >&6; }
9667 < cat >conftest.$ac_ext <<_ACEOF
9668 < /* confdefs.h.  */
9669 < _ACEOF
9670 < cat confdefs.h >>conftest.$ac_ext
9671 < cat >>conftest.$ac_ext <<_ACEOF
9672 < /* end confdefs.h.  */
9673 < $ac_includes_default
9674 < #include <openbabel/obconversion.h>
9675 < _ACEOF
9676 < rm -f conftest.$ac_objext
9677 < if { (ac_try="$ac_compile"
9678 < case "(($ac_try" in
9679 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9680 <  *) ac_try_echo=$ac_try;;
9681 < esac
9682 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9683 < $as_echo "$ac_try_echo") >&5
9684 <  (eval "$ac_compile") 2>conftest.er1
9685 <  ac_status=$?
9686 <  grep -v '^ *+' conftest.er1 >conftest.err
9687 <  rm -f conftest.er1
9688 <  cat conftest.err >&5
9689 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9690 <  (exit $ac_status); } && {
9691 <         test -z "$ac_cxx_werror_flag" ||
9692 <         test ! -s conftest.err
9693 <       } && test -s conftest.$ac_objext; then
9694 <  ac_header_compiler=yes
9695 < else
9696 <  $as_echo "$as_me: failed program was:" >&5
9697 < sed 's/^/| /' conftest.$ac_ext >&5
9698 <
9699 <        ac_header_compiler=no
9700 < fi
9701 <
9702 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9703 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9704 < $as_echo "$ac_header_compiler" >&6; }
9705 <
9706 < # Is the header present?
9707 < { $as_echo "$as_me:$LINENO: checking openbabel/obconversion.h presence" >&5
9708 < $as_echo_n "checking openbabel/obconversion.h presence... " >&6; }
9709 < cat >conftest.$ac_ext <<_ACEOF
9710 < /* confdefs.h.  */
9711 < _ACEOF
9712 < cat confdefs.h >>conftest.$ac_ext
9713 < cat >>conftest.$ac_ext <<_ACEOF
9714 < /* end confdefs.h.  */
9715 < #include <openbabel/obconversion.h>
9716 < _ACEOF
9717 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9718 < case "(($ac_try" in
9719 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9720 <  *) ac_try_echo=$ac_try;;
9721 < esac
9722 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9723 < $as_echo "$ac_try_echo") >&5
9724 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9725 <  ac_status=$?
9726 <  grep -v '^ *+' conftest.er1 >conftest.err
9727 <  rm -f conftest.er1
9728 <  cat conftest.err >&5
9729 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9730 <  (exit $ac_status); } >/dev/null && {
9731 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9732 <         test ! -s conftest.err
9733 <       }; then
9734 <  ac_header_preproc=yes
9735 < else
9736 <  $as_echo "$as_me: failed program was:" >&5
9737 < sed 's/^/| /' conftest.$ac_ext >&5
9738 <
9739 <  ac_header_preproc=no
9740 < fi
9741 <
9742 < rm -f conftest.err conftest.$ac_ext
9743 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9744 < $as_echo "$ac_header_preproc" >&6; }
9745 <
9746 < # So?  What about this header?
9747 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9748 <  yes:no: )
9749 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&5
9750 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9751 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&5
9752 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&2;}
9753 <    ac_header_preproc=yes
9754 <    ;;
9755 <  no:yes:* )
9756 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&5
9757 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&2;}
9758 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&5
9759 < $as_echo "$as_me: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&2;}
9760 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&5
9761 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&2;}
9762 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&5
9763 < $as_echo "$as_me: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9764 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&5
9765 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&2;}
9766 <    { $as_echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&5
9767 < $as_echo "$as_me: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&2;}
9768 <    ( cat <<\_ASBOX
9769 < ## ------------------------------ ##
9770 < ## Report this to gezelter@nd.edu ##
9771 < ## ------------------------------ ##
9772 < _ASBOX
9773 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9774 <    ;;
9775 < esac
9776 < { $as_echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9777 < $as_echo_n "checking for openbabel/obconversion.h... " >&6; }
9778 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9779 <  $as_echo_n "(cached) " >&6
9780 < else
9781 <  ac_cv_header_openbabel_obconversion_h=$ac_header_preproc
9782 < fi
9783 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9784 < $as_echo "$ac_cv_header_openbabel_obconversion_h" >&6; }
9785 <
9786 < fi
9787 < if test $ac_cv_header_openbabel_obconversion_h = yes; then
9788 <  openbabel_cv_obconversion_h=yes
9789 < else
9790 <  openbabel_cv_obconversion_h=no
9791 < fi
9792 <
9793 <
9794 <        cat >conftest.$ac_ext <<_ACEOF
9795 <
9796 <             /* confdefs.h.  */
9797 < _ACEOF
9798 < cat confdefs.h >>conftest.$ac_ext
9799 < cat >>conftest.$ac_ext <<_ACEOF
9800 < /* end confdefs.h.  */
9801 <
9802 < #include <openbabel/babelconfig.h>
9803 < #include <openbabel/obconversion.h>
9804 < using namespace std;
9805 < using namespace OpenBabel;
9806 <
9807 < #ifdef FC_DUMMY_MAIN
9808 < #ifndef FC_DUMMY_MAIN_EQ_F77
9809 < #  ifdef __cplusplus
9810 <     extern "C"
9811 < #  endif
9812 <   int FC_DUMMY_MAIN() { return 1; }
9813 < #endif
9814 < #endif
9815 < int
9816 < main ()
9817 < {
9818 <
9819 < OBConversion Conv(&cin, &cout);
9820 <
9821 <
9822 <  ;
9823 <  return 0;
9824 < }
9825 < _ACEOF
9826 < rm -f conftest.$ac_objext conftest$ac_exeext
9827 < if { (ac_try="$ac_link"
9828 < case "(($ac_try" in
9829 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9830 <  *) ac_try_echo=$ac_try;;
9831 < esac
9832 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9833 < $as_echo "$ac_try_echo") >&5
9834 <  (eval "$ac_link") 2>conftest.er1
9835 <  ac_status=$?
9836 <  grep -v '^ *+' conftest.er1 >conftest.err
9837 <  rm -f conftest.er1
9838 <  cat conftest.err >&5
9839 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9840 <  (exit $ac_status); } && {
9841 <         test -z "$ac_cxx_werror_flag" ||
9842 <         test ! -s conftest.err
9843 <       } && test -s conftest$ac_exeext && {
9844 <         test "$cross_compiling" = yes ||
9845 <         $as_test_x conftest$ac_exeext
9846 <       }; then
9847 <
9848 <                openbabel_lib_found="yes"
9849 <                { $as_echo "$as_me:$LINENO: result: found" >&5
9850 < $as_echo "found" >&6; }
9851 <
9852 < else
9853 <  $as_echo "$as_me: failed program was:" >&5
9854 < sed 's/^/| /' conftest.$ac_ext >&5
9855 <
9856 <
9857 <                openbabel_lib_found="no"
9858 <                { $as_echo "$as_me:$LINENO: result: not found" >&5
9859 < $as_echo "not found" >&6; }
9860 <
9861 <
9862 < fi
9863 <
9864 < rm -rf conftest.dSYM
9865 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9866 <      conftest$ac_exeext conftest.$ac_ext
9867 <        ac_ext=c
9868 < ac_cpp='$CPP $CPPFLAGS'
9869 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9870 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9871 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9872 <
9873 <        LDFLAGS="$OPENBABEL_OLD_LDFLAGS"
9874 <        CPPFLAGS="$OPENBABEL_OLD_CPPFLAGS"
9875 <
9876 <        if test "$openbabel_lib_found" = "yes" -a "$openbabel_cv_openbabel_h" = "yes" -a "$openbabel_cv_obconversion_h" = "yes"; then
9877 <                USE_OPENBABEL=yes
9878 <                OPENBABEL_INC_DIR="${OPENBABEL_HOME}/include/openbabel-2.0"
9879 <                OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
9880 <                OPENBABEL_LIB="-lopenbabel"
9881 <        else
9882 <                { $as_echo "$as_me:$LINENO: checking openbabel in ${OPENBABEL_HOME}" >&5
9883 < $as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
9884 <                OPENBABEL_INC_DIR=
9885 <                OPENBABEL_LIB_DIR=
9886 <                OPENBABEL_LIB=
9887 <                USE_OPENBABEL=no
9888 <                { $as_echo "$as_me:$LINENO: result: failed" >&5
9889 < $as_echo "failed" >&6; }
9890 <                echo ""
9891 <                echo "*********************************************************"
9892 <                echo "* WARNING: Could not find a working openbabel-2.x       *"
9893 <                echo "* installation If you need OOPSE to be able to convert  *"
9894 <                echo "* xyz or pdb files you need to specify a valid          *"
9895 <                echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
9896 <                echo "*                                                       *"
9897 <                echo "* OOPSE will still work without openbabel installed.    *"
9898 <                echo "*********************************************************"
9899 <                echo ""
9900 <        fi
9901 <
9902 <
9903 <
9904 <
9905 < fi
9906 < fi
9907 <
9908 <
9909 < # Checks for header files.
9910 < { $as_echo "$as_me:$LINENO: checking for ANSI C header files" >&5
9911 < $as_echo_n "checking for ANSI C header files... " >&6; }
9912 < if test "${ac_cv_header_stdc+set}" = set; then
9913 <  $as_echo_n "(cached) " >&6
9914 < else
9915 <  cat >conftest.$ac_ext <<_ACEOF
9916 < /* confdefs.h.  */
9917 < _ACEOF
9918 < cat confdefs.h >>conftest.$ac_ext
9919 < cat >>conftest.$ac_ext <<_ACEOF
9920 < /* end confdefs.h.  */
9921 < #include <stdlib.h>
9922 < #include <stdarg.h>
9923 < #include <string.h>
9924 < #include <float.h>
9925 <
9926 < #ifdef FC_DUMMY_MAIN
9927 < #ifndef FC_DUMMY_MAIN_EQ_F77
9928 < #  ifdef __cplusplus
9929 <     extern "C"
9930 < #  endif
9931 <   int FC_DUMMY_MAIN() { return 1; }
9932 < #endif
9933 < #endif
9934 < int
9935 < main ()
9936 < {
9937 <
9938 <  ;
9939 <  return 0;
9940 < }
9941 < _ACEOF
9942 < rm -f conftest.$ac_objext
9943 < if { (ac_try="$ac_compile"
9944 < case "(($ac_try" in
9945 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9946 <  *) ac_try_echo=$ac_try;;
9947 < esac
9948 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
9949 < $as_echo "$ac_try_echo") >&5
9950 <  (eval "$ac_compile") 2>conftest.er1
9951 <  ac_status=$?
9952 <  grep -v '^ *+' conftest.er1 >conftest.err
9953 <  rm -f conftest.er1
9954 <  cat conftest.err >&5
9955 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
9956 <  (exit $ac_status); } && {
9957 <         test -z "$ac_c_werror_flag" ||
9958 <         test ! -s conftest.err
9959 <       } && test -s conftest.$ac_objext; then
9960 <  ac_cv_header_stdc=yes
9961 < else
9962 <  $as_echo "$as_me: failed program was:" >&5
9963 < sed 's/^/| /' conftest.$ac_ext >&5
9964 <
9965 <        ac_cv_header_stdc=no
9966 < fi
9967 <
9968 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9969 <
9970 < if test $ac_cv_header_stdc = yes; then
9971 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
9972 <  cat >conftest.$ac_ext <<_ACEOF
9973 < /* confdefs.h.  */
9974 < _ACEOF
9975 < cat confdefs.h >>conftest.$ac_ext
9976 < cat >>conftest.$ac_ext <<_ACEOF
9977 < /* end confdefs.h.  */
9978 < #include <string.h>
9979 <
9980 < _ACEOF
9981 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
9982 <  $EGREP "memchr" >/dev/null 2>&1; then
9983 <  :
9984 < else
9985 <  ac_cv_header_stdc=no
9986 < fi
9987 < rm -f conftest*
9988 <
9989 < fi
9990 <
9991 < if test $ac_cv_header_stdc = yes; then
9992 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
9993 <  cat >conftest.$ac_ext <<_ACEOF
9994 < /* confdefs.h.  */
9995 < _ACEOF
9996 < cat confdefs.h >>conftest.$ac_ext
9997 < cat >>conftest.$ac_ext <<_ACEOF
9998 < /* end confdefs.h.  */
9999 < #include <stdlib.h>
10000 <
10001 < _ACEOF
10002 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
10003 <  $EGREP "free" >/dev/null 2>&1; then
10004 <  :
10005 < else
10006 <  ac_cv_header_stdc=no
10007 < fi
10008 < rm -f conftest*
10009 <
10010 < fi
10011 <
10012 < if test $ac_cv_header_stdc = yes; then
10013 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
10014 <  if test "$cross_compiling" = yes; then
10015 <  :
10016 < else
10017 <  cat >conftest.$ac_ext <<_ACEOF
10018 < /* confdefs.h.  */
10019 < _ACEOF
10020 < cat confdefs.h >>conftest.$ac_ext
10021 < cat >>conftest.$ac_ext <<_ACEOF
10022 < /* end confdefs.h.  */
10023 < #include <ctype.h>
10024 < #include <stdlib.h>
10025 < #if ((' ' & 0x0FF) == 0x020)
10026 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
10027 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
10028 < #else
10029 < # define ISLOWER(c) \
10030 <                   (('a' <= (c) && (c) <= 'i') \
10031 <                     || ('j' <= (c) && (c) <= 'r') \
10032 <                     || ('s' <= (c) && (c) <= 'z'))
10033 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
10034 < #endif
10035 <
10036 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
10037 < int
10038 < main ()
10039 < {
10040 <  int i;
10041 <  for (i = 0; i < 256; i++)
10042 <    if (XOR (islower (i), ISLOWER (i))
10043 <        || toupper (i) != TOUPPER (i))
10044 <      return 2;
10045 <  return 0;
10046 < }
10047 < _ACEOF
10048 < rm -f conftest$ac_exeext
10049 < if { (ac_try="$ac_link"
10050 < case "(($ac_try" in
10051 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10052 <  *) ac_try_echo=$ac_try;;
10053 < esac
10054 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10055 < $as_echo "$ac_try_echo") >&5
10056 <  (eval "$ac_link") 2>&5
10057 <  ac_status=$?
10058 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10059 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10060 <  { (case "(($ac_try" in
10061 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10062 <  *) ac_try_echo=$ac_try;;
10063 < esac
10064 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10065 < $as_echo "$ac_try_echo") >&5
10066 <  (eval "$ac_try") 2>&5
10067 <  ac_status=$?
10068 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10069 <  (exit $ac_status); }; }; then
10070 <  :
10071 < else
10072 <  $as_echo "$as_me: program exited with status $ac_status" >&5
10073 < $as_echo "$as_me: failed program was:" >&5
10074 < sed 's/^/| /' conftest.$ac_ext >&5
10075 <
10076 < ( exit $ac_status )
10077 < ac_cv_header_stdc=no
10078 < fi
10079 < rm -rf conftest.dSYM
10080 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10081 < fi
10082 <
10083 <
10084 < fi
10085 < fi
10086 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
10087 < $as_echo "$ac_cv_header_stdc" >&6; }
10088 < if test $ac_cv_header_stdc = yes; then
10089 <
10090 < cat >>confdefs.h <<\_ACEOF
10091 < #define STDC_HEADERS 1
10092 < _ACEOF
10093 <
10094 < fi
10095 <
10096 <
10097 <
10098 <
10099 <
10100 <
10101 <
10102 <
10103 <
10104 <
10105 <
10106 <
10107 <
10108 <
10109 <
10110 <
10111 < 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
10112 < do
10113 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
10114 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10115 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10116 < $as_echo_n "checking for $ac_header... " >&6; }
10117 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10118 <  $as_echo_n "(cached) " >&6
10119 < fi
10120 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10121 <                 $as_echo "$as_val"'`
10122 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10123 < $as_echo "$ac_res" >&6; }
10124 < else
10125 <  # Is the header compilable?
10126 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
10127 < $as_echo_n "checking $ac_header usability... " >&6; }
10128 < cat >conftest.$ac_ext <<_ACEOF
10129 < /* confdefs.h.  */
10130 < _ACEOF
10131 < cat confdefs.h >>conftest.$ac_ext
10132 < cat >>conftest.$ac_ext <<_ACEOF
10133 < /* end confdefs.h.  */
10134 < $ac_includes_default
10135 < #include <$ac_header>
10136 < _ACEOF
10137 < rm -f conftest.$ac_objext
10138 < if { (ac_try="$ac_compile"
10139 < case "(($ac_try" in
10140 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10141 <  *) ac_try_echo=$ac_try;;
10142 < esac
10143 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10144 < $as_echo "$ac_try_echo") >&5
10145 <  (eval "$ac_compile") 2>conftest.er1
10146 <  ac_status=$?
10147 <  grep -v '^ *+' conftest.er1 >conftest.err
10148 <  rm -f conftest.er1
10149 <  cat conftest.err >&5
10150 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10151 <  (exit $ac_status); } && {
10152 <         test -z "$ac_c_werror_flag" ||
10153 <         test ! -s conftest.err
10154 <       } && test -s conftest.$ac_objext; then
10155 <  ac_header_compiler=yes
10156 < else
10157 <  $as_echo "$as_me: failed program was:" >&5
10158 < sed 's/^/| /' conftest.$ac_ext >&5
10159 <
10160 <        ac_header_compiler=no
10161 < fi
10162 <
10163 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10164 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10165 < $as_echo "$ac_header_compiler" >&6; }
10166 <
10167 < # Is the header present?
10168 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
10169 < $as_echo_n "checking $ac_header presence... " >&6; }
10170 < cat >conftest.$ac_ext <<_ACEOF
10171 < /* confdefs.h.  */
10172 < _ACEOF
10173 < cat confdefs.h >>conftest.$ac_ext
10174 < cat >>conftest.$ac_ext <<_ACEOF
10175 < /* end confdefs.h.  */
10176 < #include <$ac_header>
10177 < _ACEOF
10178 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10179 < case "(($ac_try" in
10180 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10181 <  *) ac_try_echo=$ac_try;;
10182 < esac
10183 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10184 < $as_echo "$ac_try_echo") >&5
10185 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10186 <  ac_status=$?
10187 <  grep -v '^ *+' conftest.er1 >conftest.err
10188 <  rm -f conftest.er1
10189 <  cat conftest.err >&5
10190 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10191 <  (exit $ac_status); } >/dev/null && {
10192 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10193 <         test ! -s conftest.err
10194 <       }; then
10195 <  ac_header_preproc=yes
10196 < else
10197 <  $as_echo "$as_me: failed program was:" >&5
10198 < sed 's/^/| /' conftest.$ac_ext >&5
10199 <
10200 <  ac_header_preproc=no
10201 < fi
10202 <
10203 < rm -f conftest.err conftest.$ac_ext
10204 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10205 < $as_echo "$ac_header_preproc" >&6; }
10206 <
10207 < # So?  What about this header?
10208 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10209 <  yes:no: )
10210 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10211 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10212 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10213 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10214 <    ac_header_preproc=yes
10215 <    ;;
10216 <  no:yes:* )
10217 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10218 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10219 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10220 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10221 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10222 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10223 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10224 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10225 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10226 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10227 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10228 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10229 <    ( cat <<\_ASBOX
10230 < ## ------------------------------ ##
10231 < ## Report this to gezelter@nd.edu ##
10232 < ## ------------------------------ ##
10233 < _ASBOX
10234 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10235 <    ;;
10236 < esac
10237 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10238 < $as_echo_n "checking for $ac_header... " >&6; }
10239 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10240 <  $as_echo_n "(cached) " >&6
10241 < else
10242 <  eval "$as_ac_Header=\$ac_header_preproc"
10243 < fi
10244 < ac_res=`eval 'as_val=${'$as_ac_Header'}
10245 <                 $as_echo "$as_val"'`
10246 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
10247 < $as_echo "$ac_res" >&6; }
10248 <
10249 < fi
10250 < if test `eval 'as_val=${'$as_ac_Header'}
10251 <                 $as_echo "$as_val"'` = yes; then
10252 <  cat >>confdefs.h <<_ACEOF
10253 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
10254 < _ACEOF
10255 <
10256 < fi
10257 <
10258 < done
10259 <
10260 <
10261 < # Checks for typedefs, structures, and compiler characteristics.
10262 < { $as_echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
10263 < $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
10264 < if test "${ac_cv_header_stdbool_h+set}" = set; then
10265 <  $as_echo_n "(cached) " >&6
10266 < else
10267 <  cat >conftest.$ac_ext <<_ACEOF
10268 < /* confdefs.h.  */
10269 < _ACEOF
10270 < cat confdefs.h >>conftest.$ac_ext
10271 < cat >>conftest.$ac_ext <<_ACEOF
10272 < /* end confdefs.h.  */
10273 <
10274 < #include <stdbool.h>
10275 < #ifndef bool
10276 < "error: bool is not defined"
10277 < #endif
10278 < #ifndef false
10279 < "error: false is not defined"
10280 < #endif
10281 < #if false
10282 < "error: false is not 0"
10283 < #endif
10284 < #ifndef true
10285 < "error: true is not defined"
10286 < #endif
10287 < #if true != 1
10288 < "error: true is not 1"
10289 < #endif
10290 < #ifndef __bool_true_false_are_defined
10291 < "error: __bool_true_false_are_defined is not defined"
10292 < #endif
10293 <
10294 <        struct s { _Bool s: 1; _Bool t; } s;
10295 <
10296 <        char a[true == 1 ? 1 : -1];
10297 <        char b[false == 0 ? 1 : -1];
10298 <        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
10299 <        char d[(bool) 0.5 == true ? 1 : -1];
10300 <        bool e = &s;
10301 <        char f[(_Bool) 0.0 == false ? 1 : -1];
10302 <        char g[true];
10303 <        char h[sizeof (_Bool)];
10304 <        char i[sizeof s.t];
10305 <        enum { j = false, k = true, l = false * true, m = true * 256 };
10306 <        /* The following fails for
10307 <           HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
10308 <        _Bool n[m];
10309 <        char o[sizeof n == m * sizeof n[0] ? 1 : -1];
10310 <        char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
10311 < #       if defined __xlc__ || defined __GNUC__
10312 <         /* Catch a bug in IBM AIX xlc compiler version 6.0.0.0
10313 <            reported by James Lemley on 2005-10-05; see
10314 <            http://lists.gnu.org/archive/html/bug-coreutils/2005-10/msg00086.html
10315 <            This test is not quite right, since xlc is allowed to
10316 <            reject this program, as the initializer for xlcbug is
10317 <            not one of the forms that C requires support for.
10318 <            However, doing the test right would require a runtime
10319 <            test, and that would make cross-compilation harder.
10320 <            Let us hope that IBM fixes the xlc bug, and also adds
10321 <            support for this kind of constant expression.  In the
10322 <            meantime, this test will reject xlc, which is OK, since
10323 <            our stdbool.h substitute should suffice.  We also test
10324 <            this with GCC, where it should work, to detect more
10325 <            quickly whether someone messes up the test in the
10326 <            future.  */
10327 <         char digs[] = "0123456789";
10328 <         int xlcbug = 1 / (&(digs + 5)[-2 + (bool) 1] == &digs[4] ? 1 : -1);
10329 < #       endif
10330 <        /* Catch a bug in an HP-UX C compiler.  See
10331 <           http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
10332 <           http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
10333 <         */
10334 <        _Bool q = true;
10335 <        _Bool *pq = &q;
10336 <
10337 < #ifdef FC_DUMMY_MAIN
10338 < #ifndef FC_DUMMY_MAIN_EQ_F77
10339 < #  ifdef __cplusplus
10340 <     extern "C"
10341 < #  endif
10342 <   int FC_DUMMY_MAIN() { return 1; }
10343 < #endif
10344 < #endif
10345 < int
10346 < main ()
10347 < {
10348 <
10349 <        *pq |= q;
10350 <        *pq |= ! q;
10351 <        /* Refer to every declared value, to avoid compiler optimizations.  */
10352 <        return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
10353 <                + !m + !n + !o + !p + !q + !pq);
10354 <
10355 <  ;
10356 <  return 0;
10357 < }
10358 < _ACEOF
10359 < rm -f conftest.$ac_objext
10360 < if { (ac_try="$ac_compile"
10361 < case "(($ac_try" in
10362 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10363 <  *) ac_try_echo=$ac_try;;
10364 < esac
10365 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10366 < $as_echo "$ac_try_echo") >&5
10367 <  (eval "$ac_compile") 2>conftest.er1
10368 <  ac_status=$?
10369 <  grep -v '^ *+' conftest.er1 >conftest.err
10370 <  rm -f conftest.er1
10371 <  cat conftest.err >&5
10372 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10373 <  (exit $ac_status); } && {
10374 <         test -z "$ac_c_werror_flag" ||
10375 <         test ! -s conftest.err
10376 <       } && test -s conftest.$ac_objext; then
10377 <  ac_cv_header_stdbool_h=yes
10378 < else
10379 <  $as_echo "$as_me: failed program was:" >&5
10380 < sed 's/^/| /' conftest.$ac_ext >&5
10381 <
10382 <        ac_cv_header_stdbool_h=no
10383 < fi
10384 <
10385 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10386 < fi
10387 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
10388 < $as_echo "$ac_cv_header_stdbool_h" >&6; }
10389 < { $as_echo "$as_me:$LINENO: checking for _Bool" >&5
10390 < $as_echo_n "checking for _Bool... " >&6; }
10391 < if test "${ac_cv_type__Bool+set}" = set; then
10392 <  $as_echo_n "(cached) " >&6
10393 < else
10394 <  ac_cv_type__Bool=no
10395 < cat >conftest.$ac_ext <<_ACEOF
10396 < /* confdefs.h.  */
10397 < _ACEOF
10398 < cat confdefs.h >>conftest.$ac_ext
10399 < cat >>conftest.$ac_ext <<_ACEOF
10400 < /* end confdefs.h.  */
10401 < $ac_includes_default
10402 < #ifdef FC_DUMMY_MAIN
10403 < #ifndef FC_DUMMY_MAIN_EQ_F77
10404 < #  ifdef __cplusplus
10405 <     extern "C"
10406 < #  endif
10407 <   int FC_DUMMY_MAIN() { return 1; }
10408 < #endif
10409 < #endif
10410 < int
10411 < main ()
10412 < {
10413 < if (sizeof (_Bool))
10414 <       return 0;
10415 <  ;
10416 <  return 0;
10417 < }
10418 < _ACEOF
10419 < rm -f conftest.$ac_objext
10420 < if { (ac_try="$ac_compile"
10421 < case "(($ac_try" in
10422 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10423 <  *) ac_try_echo=$ac_try;;
10424 < esac
10425 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10426 < $as_echo "$ac_try_echo") >&5
10427 <  (eval "$ac_compile") 2>conftest.er1
10428 <  ac_status=$?
10429 <  grep -v '^ *+' conftest.er1 >conftest.err
10430 <  rm -f conftest.er1
10431 <  cat conftest.err >&5
10432 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10433 <  (exit $ac_status); } && {
10434 <         test -z "$ac_c_werror_flag" ||
10435 <         test ! -s conftest.err
10436 <       } && test -s conftest.$ac_objext; then
10437 <  cat >conftest.$ac_ext <<_ACEOF
10438 < /* confdefs.h.  */
10439 < _ACEOF
10440 < cat confdefs.h >>conftest.$ac_ext
10441 < cat >>conftest.$ac_ext <<_ACEOF
10442 < /* end confdefs.h.  */
10443 < $ac_includes_default
10444 < #ifdef FC_DUMMY_MAIN
10445 < #ifndef FC_DUMMY_MAIN_EQ_F77
10446 < #  ifdef __cplusplus
10447 <     extern "C"
10448 < #  endif
10449 <   int FC_DUMMY_MAIN() { return 1; }
10450 < #endif
10451 < #endif
10452 < int
10453 < main ()
10454 < {
10455 < if (sizeof ((_Bool)))
10456 <          return 0;
10457 <  ;
10458 <  return 0;
10459 < }
10460 < _ACEOF
10461 < rm -f conftest.$ac_objext
10462 < if { (ac_try="$ac_compile"
10463 < case "(($ac_try" in
10464 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10465 <  *) ac_try_echo=$ac_try;;
10466 < esac
10467 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10468 < $as_echo "$ac_try_echo") >&5
10469 <  (eval "$ac_compile") 2>conftest.er1
10470 <  ac_status=$?
10471 <  grep -v '^ *+' conftest.er1 >conftest.err
10472 <  rm -f conftest.er1
10473 <  cat conftest.err >&5
10474 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10475 <  (exit $ac_status); } && {
10476 <         test -z "$ac_c_werror_flag" ||
10477 <         test ! -s conftest.err
10478 <       } && test -s conftest.$ac_objext; then
10479 <  :
10480 < else
10481 <  $as_echo "$as_me: failed program was:" >&5
10482 < sed 's/^/| /' conftest.$ac_ext >&5
10483 <
10484 <        ac_cv_type__Bool=yes
10485 < fi
10486 <
10487 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10488 < else
10489 <  $as_echo "$as_me: failed program was:" >&5
10490 < sed 's/^/| /' conftest.$ac_ext >&5
10491 <
10492 <
10493 < fi
10494 <
10495 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10496 < fi
10497 < { $as_echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
10498 < $as_echo "$ac_cv_type__Bool" >&6; }
10499 < if test $ac_cv_type__Bool = yes; then
10500 <
10501 < cat >>confdefs.h <<_ACEOF
10502 < #define HAVE__BOOL 1
10503 < _ACEOF
10504 <
10505 <
10506 < fi
10507 <
10508 < if test $ac_cv_header_stdbool_h = yes; then
10509 <
10510 < cat >>confdefs.h <<\_ACEOF
10511 < #define HAVE_STDBOOL_H 1
10512 < _ACEOF
10513 <
10514 < fi
10515 <
10516 < { $as_echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
10517 < $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
10518 < if test "${ac_cv_c_const+set}" = set; then
10519 <  $as_echo_n "(cached) " >&6
10520 < else
10521 <  cat >conftest.$ac_ext <<_ACEOF
10522 < /* confdefs.h.  */
10523 < _ACEOF
10524 < cat confdefs.h >>conftest.$ac_ext
10525 < cat >>conftest.$ac_ext <<_ACEOF
10526 < /* end confdefs.h.  */
10527 <
10528 < #ifdef FC_DUMMY_MAIN
10529 < #ifndef FC_DUMMY_MAIN_EQ_F77
10530 < #  ifdef __cplusplus
10531 <     extern "C"
10532 < #  endif
10533 <   int FC_DUMMY_MAIN() { return 1; }
10534 < #endif
10535 < #endif
10536 < int
10537 < main ()
10538 < {
10539 < /* FIXME: Include the comments suggested by Paul. */
10540 < #ifndef __cplusplus
10541 <  /* Ultrix mips cc rejects this.  */
10542 <  typedef int charset[2];
10543 <  const charset cs;
10544 <  /* SunOS 4.1.1 cc rejects this.  */
10545 <  char const *const *pcpcc;
10546 <  char **ppc;
10547 <  /* NEC SVR4.0.2 mips cc rejects this.  */
10548 <  struct point {int x, y;};
10549 <  static struct point const zero = {0,0};
10550 <  /* AIX XL C 1.02.0.0 rejects this.
10551 <     It does not let you subtract one const X* pointer from another in
10552 <     an arm of an if-expression whose if-part is not a constant
10553 <     expression */
10554 <  const char *g = "string";
10555 <  pcpcc = &g + (g ? g-g : 0);
10556 <  /* HPUX 7.0 cc rejects these. */
10557 <  ++pcpcc;
10558 <  ppc = (char**) pcpcc;
10559 <  pcpcc = (char const *const *) ppc;
10560 <  { /* SCO 3.2v4 cc rejects this.  */
10561 <    char *t;
10562 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
10563 <
10564 <    *t++ = 0;
10565 <    if (s) return 0;
10566 <  }
10567 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
10568 <    int x[] = {25, 17};
10569 <    const int *foo = &x[0];
10570 <    ++foo;
10571 <  }
10572 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
10573 <    typedef const int *iptr;
10574 <    iptr p = 0;
10575 <    ++p;
10576 <  }
10577 <  { /* AIX XL C 1.02.0.0 rejects this saying
10578 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
10579 <    struct s { int j; const int *ap[3]; };
10580 <    struct s *b; b->j = 5;
10581 <  }
10582 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
10583 <    const int foo = 10;
10584 <    if (!foo) return 0;
10585 <  }
10586 <  return !cs[0] && !zero.x;
10587 < #endif
10588 <
10589 <  ;
10590 <  return 0;
10591 < }
10592 < _ACEOF
10593 < rm -f conftest.$ac_objext
10594 < if { (ac_try="$ac_compile"
10595 < case "(($ac_try" in
10596 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10597 <  *) ac_try_echo=$ac_try;;
10598 < esac
10599 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10600 < $as_echo "$ac_try_echo") >&5
10601 <  (eval "$ac_compile") 2>conftest.er1
10602 <  ac_status=$?
10603 <  grep -v '^ *+' conftest.er1 >conftest.err
10604 <  rm -f conftest.er1
10605 <  cat conftest.err >&5
10606 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10607 <  (exit $ac_status); } && {
10608 <         test -z "$ac_c_werror_flag" ||
10609 <         test ! -s conftest.err
10610 <       } && test -s conftest.$ac_objext; then
10611 <  ac_cv_c_const=yes
10612 < else
10613 <  $as_echo "$as_me: failed program was:" >&5
10614 < sed 's/^/| /' conftest.$ac_ext >&5
10615 <
10616 <        ac_cv_c_const=no
10617 < fi
10618 <
10619 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10620 < fi
10621 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
10622 < $as_echo "$ac_cv_c_const" >&6; }
10623 < if test $ac_cv_c_const = no; then
10624 <
10625 < cat >>confdefs.h <<\_ACEOF
10626 < #define const /**/
10627 < _ACEOF
10628 <
10629 < fi
10630 <
10631 < { $as_echo "$as_me:$LINENO: checking for inline" >&5
10632 < $as_echo_n "checking for inline... " >&6; }
10633 < if test "${ac_cv_c_inline+set}" = set; then
10634 <  $as_echo_n "(cached) " >&6
10635 < else
10636 <  ac_cv_c_inline=no
10637 < for ac_kw in inline __inline__ __inline; do
10638 <  cat >conftest.$ac_ext <<_ACEOF
10639 < /* confdefs.h.  */
10640 < _ACEOF
10641 < cat confdefs.h >>conftest.$ac_ext
10642 < cat >>conftest.$ac_ext <<_ACEOF
10643 < /* end confdefs.h.  */
10644 < #ifndef __cplusplus
10645 < typedef int foo_t;
10646 < static $ac_kw foo_t static_foo () {return 0; }
10647 < $ac_kw foo_t foo () {return 0; }
10648 < #endif
10649 <
10650 < _ACEOF
10651 < rm -f conftest.$ac_objext
10652 < if { (ac_try="$ac_compile"
10653 < case "(($ac_try" in
10654 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10655 <  *) ac_try_echo=$ac_try;;
10656 < esac
10657 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10658 < $as_echo "$ac_try_echo") >&5
10659 <  (eval "$ac_compile") 2>conftest.er1
10660 <  ac_status=$?
10661 <  grep -v '^ *+' conftest.er1 >conftest.err
10662 <  rm -f conftest.er1
10663 <  cat conftest.err >&5
10664 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10665 <  (exit $ac_status); } && {
10666 <         test -z "$ac_c_werror_flag" ||
10667 <         test ! -s conftest.err
10668 <       } && test -s conftest.$ac_objext; then
10669 <  ac_cv_c_inline=$ac_kw
10670 < else
10671 <  $as_echo "$as_me: failed program was:" >&5
10672 < sed 's/^/| /' conftest.$ac_ext >&5
10673 <
10674 <
10675 < fi
10676 <
10677 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10678 <  test "$ac_cv_c_inline" != no && break
10679 < done
10680 <
10681 < fi
10682 < { $as_echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
10683 < $as_echo "$ac_cv_c_inline" >&6; }
10684 <
10685 <
10686 < case $ac_cv_c_inline in
10687 <  inline | yes) ;;
10688 <  *)
10689 <    case $ac_cv_c_inline in
10690 <      no) ac_val=;;
10691 <      *) ac_val=$ac_cv_c_inline;;
10692 <    esac
10693 <    cat >>confdefs.h <<_ACEOF
10694 < #ifndef __cplusplus
10695 < #define inline $ac_val
10696 < #endif
10697 < _ACEOF
10698 <    ;;
10699 < esac
10700 <
10701 < { $as_echo "$as_me:$LINENO: checking for size_t" >&5
10702 < $as_echo_n "checking for size_t... " >&6; }
10703 < if test "${ac_cv_type_size_t+set}" = set; then
10704 <  $as_echo_n "(cached) " >&6
10705 < else
10706 <  ac_cv_type_size_t=no
10707 < cat >conftest.$ac_ext <<_ACEOF
10708 < /* confdefs.h.  */
10709 < _ACEOF
10710 < cat confdefs.h >>conftest.$ac_ext
10711 < cat >>conftest.$ac_ext <<_ACEOF
10712 < /* end confdefs.h.  */
10713 < $ac_includes_default
10714 < #ifdef FC_DUMMY_MAIN
10715 < #ifndef FC_DUMMY_MAIN_EQ_F77
10716 < #  ifdef __cplusplus
10717 <     extern "C"
10718 < #  endif
10719 <   int FC_DUMMY_MAIN() { return 1; }
10720 < #endif
10721 < #endif
10722 < int
10723 < main ()
10724 < {
10725 < if (sizeof (size_t))
10726 <       return 0;
10727 <  ;
10728 <  return 0;
10729 < }
10730 < _ACEOF
10731 < rm -f conftest.$ac_objext
10732 < if { (ac_try="$ac_compile"
10733 < case "(($ac_try" in
10734 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10735 <  *) ac_try_echo=$ac_try;;
10736 < esac
10737 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10738 < $as_echo "$ac_try_echo") >&5
10739 <  (eval "$ac_compile") 2>conftest.er1
10740 <  ac_status=$?
10741 <  grep -v '^ *+' conftest.er1 >conftest.err
10742 <  rm -f conftest.er1
10743 <  cat conftest.err >&5
10744 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10745 <  (exit $ac_status); } && {
10746 <         test -z "$ac_c_werror_flag" ||
10747 <         test ! -s conftest.err
10748 <       } && test -s conftest.$ac_objext; then
10749 <  cat >conftest.$ac_ext <<_ACEOF
10750 < /* confdefs.h.  */
10751 < _ACEOF
10752 < cat confdefs.h >>conftest.$ac_ext
10753 < cat >>conftest.$ac_ext <<_ACEOF
10754 < /* end confdefs.h.  */
10755 < $ac_includes_default
10756 < #ifdef FC_DUMMY_MAIN
10757 < #ifndef FC_DUMMY_MAIN_EQ_F77
10758 < #  ifdef __cplusplus
10759 <     extern "C"
10760 < #  endif
10761 <   int FC_DUMMY_MAIN() { return 1; }
10762 < #endif
10763 < #endif
10764 < int
10765 < main ()
10766 < {
10767 < if (sizeof ((size_t)))
10768 <          return 0;
10769 <  ;
10770 <  return 0;
10771 < }
10772 < _ACEOF
10773 < rm -f conftest.$ac_objext
10774 < if { (ac_try="$ac_compile"
10775 < case "(($ac_try" in
10776 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10777 <  *) ac_try_echo=$ac_try;;
10778 < esac
10779 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10780 < $as_echo "$ac_try_echo") >&5
10781 <  (eval "$ac_compile") 2>conftest.er1
10782 <  ac_status=$?
10783 <  grep -v '^ *+' conftest.er1 >conftest.err
10784 <  rm -f conftest.er1
10785 <  cat conftest.err >&5
10786 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10787 <  (exit $ac_status); } && {
10788 <         test -z "$ac_c_werror_flag" ||
10789 <         test ! -s conftest.err
10790 <       } && test -s conftest.$ac_objext; then
10791 <  :
10792 < else
10793 <  $as_echo "$as_me: failed program was:" >&5
10794 < sed 's/^/| /' conftest.$ac_ext >&5
10795 <
10796 <        ac_cv_type_size_t=yes
10797 < fi
10798 <
10799 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10800 < else
10801 <  $as_echo "$as_me: failed program was:" >&5
10802 < sed 's/^/| /' conftest.$ac_ext >&5
10803 <
10804 <
10805 < fi
10806 <
10807 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10808 < fi
10809 < { $as_echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
10810 < $as_echo "$ac_cv_type_size_t" >&6; }
10811 < if test $ac_cv_type_size_t = yes; then
10812 <  :
10813 < else
10814 <
10815 < cat >>confdefs.h <<_ACEOF
10816 < #define size_t unsigned int
5344 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
5345 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -lfftw" >&5
5346 > $as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
5347 > if ${ac_cv_lib_fftw_fftwnd_one+:} false; then :
5348 >  $as_echo_n "(cached) " >&6
5349 > else
5350 >  ac_check_lib_save_LIBS=$LIBS
5351 > LIBS="-lfftw  $LIBS"
5352 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5353 > /* end confdefs.h.  */
5354 >
5355 > /* Override any GCC internal prototype to avoid an error.
5356 >   Use char because int might match the return type of a GCC
5357 >   builtin and then its argument prototype would still apply.  */
5358 > #ifdef __cplusplus
5359 > extern "C"
5360 > #endif
5361 > char fftwnd_one ();
5362 > int
5363 > main ()
5364 > {
5365 > return fftwnd_one ();
5366 >  ;
5367 >  return 0;
5368 > }
5369 > _ACEOF
5370 > if ac_fn_c_try_link "$LINENO"; then :
5371 >  ac_cv_lib_fftw_fftwnd_one=yes
5372 > else
5373 >  ac_cv_lib_fftw_fftwnd_one=no
5374 > fi
5375 > rm -f core conftest.err conftest.$ac_objext \
5376 >    conftest$ac_exeext conftest.$ac_ext
5377 > LIBS=$ac_check_lib_save_LIBS
5378 > fi
5379 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw_fftwnd_one" >&5
5380 > $as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
5381 > if test "x$ac_cv_lib_fftw_fftwnd_one" = xyes; then :
5382 >  fftw_cv_libfftw=yes
5383 > else
5384 >  fftw_cv_libfftw=no
5385 > fi
5386 >
5387 >        ac_fn_c_check_header_mongrel "$LINENO" "fftw.h" "ac_cv_header_fftw_h" "$ac_includes_default"
5388 > if test "x$ac_cv_header_fftw_h" = xyes; then :
5389 >  fftw_cv_fftw_h=yes
5390 > else
5391 >  fftw_cv_fftw_h=no
5392 > fi
5393 >
5394 >
5395 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
5396 >          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -ldfftw" >&5
5397 > $as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
5398 > if ${ac_cv_lib_dfftw_fftwnd_one+:} false; then :
5399 >  $as_echo_n "(cached) " >&6
5400 > else
5401 >  ac_check_lib_save_LIBS=$LIBS
5402 > LIBS="-ldfftw  $LIBS"
5403 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5404 > /* end confdefs.h.  */
5405 >
5406 > /* Override any GCC internal prototype to avoid an error.
5407 >   Use char because int might match the return type of a GCC
5408 >   builtin and then its argument prototype would still apply.  */
5409 > #ifdef __cplusplus
5410 > extern "C"
5411 > #endif
5412 > char fftwnd_one ();
5413 > int
5414 > main ()
5415 > {
5416 > return fftwnd_one ();
5417 >  ;
5418 >  return 0;
5419 > }
5420 > _ACEOF
5421 > if ac_fn_c_try_link "$LINENO"; then :
5422 >  ac_cv_lib_dfftw_fftwnd_one=yes
5423 > else
5424 >  ac_cv_lib_dfftw_fftwnd_one=no
5425 > fi
5426 > rm -f core conftest.err conftest.$ac_objext \
5427 >    conftest$ac_exeext conftest.$ac_ext
5428 > LIBS=$ac_check_lib_save_LIBS
5429 > fi
5430 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
5431 > $as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
5432 > if test "x$ac_cv_lib_dfftw_fftwnd_one" = xyes; then :
5433 >  fftw_cv_libdfftw=yes
5434 > else
5435 >  fftw_cv_libdfftw=no
5436 > fi
5437 >
5438 >          ac_fn_c_check_header_mongrel "$LINENO" "dfftw.h" "ac_cv_header_dfftw_h" "$ac_includes_default"
5439 > if test "x$ac_cv_header_dfftw_h" = xyes; then :
5440 >  fftw_cv_dfftw_h=yes
5441 > else
5442 >  fftw_cv_dfftw_h=no
5443 > fi
5444 >
5445 >
5446 >        fi
5447 >      fi
5448 >      ac_ext=c
5449 > ac_cpp='$CPP $CPPFLAGS'
5450 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5451 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5452 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5453 >
5454 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
5455 >
5456 > $as_echo "#define HAVE_FFTW3_H 1" >>confdefs.h
5457 >
5458 >        FFTW_INC_DIR="${FFTW_HOME}/include"
5459 >        FFTW_LIB_DIR="${FFTW_HOME}/lib"
5460 >        FFTW_LIBS="-lfftw3"
5461 >      else
5462 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
5463 >
5464 > $as_echo "#define HAVE_FFTW_H 1" >>confdefs.h
5465 >
5466 >          FFTW_INC_DIR="${FFTW_HOME}/include"
5467 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
5468 >          FFTW_LIBS="-lfftw"
5469 >        else
5470 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
5471 >
5472 > $as_echo "#define HAVE_DFFTW_H 1" >>confdefs.h
5473 >
5474 >            FFTW_INC_DIR="${FFTW_HOME}/include"
5475 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
5476 >            FFTW_LIBS="-ldfftw"
5477 >          else
5478 >            { $as_echo "$as_me:${as_lineno-$LINENO}: checking fftw in ${FFTW_HOME}" >&5
5479 > $as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
5480 >            FFTW_INC_DIR=
5481 >            FFTW_LIB_DIR=
5482 >            FFTW_LIBS=
5483 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
5484 >            CFLAGS="$FFTW_OLD_CFLAGS"
5485 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5486 > $as_echo "failed" >&6; }
5487 >            echo ""
5488 >            echo "*********************************************************"
5489 >            echo "* WARNING: Could not find a working FFTW installation   *"
5490 >            echo "* If you need the staticProps program to be able to     *"
5491 >            echo "* compute undulation spectra, be sure to specify a      *"
5492 >            echo "* valid fftw installation with --with-fftw=DIR          *"
5493 >            echo "*                                                       *"
5494 >            echo "* OpenMD will still work without fftw installed.        *"
5495 >            echo "*********************************************************"
5496 >            echo ""
5497 >          fi
5498 >        fi
5499 >      fi
5500 >
5501 >
5502 >
5503 >    fi
5504 >  fi
5505 > fi
5506 >
5507 > #
5508 > # Handle user hints
5509 > #
5510 >
5511 > # Check whether --with-qhull was given.
5512 > if test "${with_qhull+set}" = set; then :
5513 >  withval=$with_qhull; qhull_dir="$withval"
5514 > else
5515 >  qhull_dir="not_set"
5516 > fi
5517 >
5518 > QHULL_INC_DIR=
5519 > QHULL_LIB_DIR=
5520 > QHULL=
5521 > USE_QHULL=no
5522 >
5523 > if test "$qhull_dir" != "no"; then
5524 >   if test "$qhull_dir" != "not_set" ; then
5525 >     if test -d "$qhull_dir"; then
5526 >       QHULL_HOME="$qhull_dir"
5527 >     else
5528 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
5529 > $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
5530 >       QHULL_HOME=/usr/local
5531 >       if test ! -f "${QHULL_HOME}/include/qhull/libqhull.h"; then
5532 >          QHULL_HOME=/usr
5533 >       fi
5534 >     fi
5535 >   fi
5536 >   #
5537 >   # Locate qhull, if wanted
5538 >   #
5539 >   if test -n "${QHULL_HOME}"; then
5540 >        { $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
5541 > $as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
5542 >
5543 >        ac_ext=c
5544 > ac_cpp='$CPP $CPPFLAGS'
5545 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5546 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5547 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5548 >
5549 >        QHULL_OLD_LDFLAGS=$LDFLAGS
5550 >        QHULL_OLD_CFLAGS=$CFLAGS
5551 >        QHULL_OLD_CPPFLAGS=$CPPFLAGS
5552 >        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
5553 >        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
5554 >        CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
5555 >        ac_fn_c_check_header_mongrel "$LINENO" "qhull/libqhull.h" "ac_cv_header_qhull_libqhull_h" "$ac_includes_default"
5556 > if test "x$ac_cv_header_qhull_libqhull_h" = xyes; then :
5557 >  qhull_cv_libqhull_h=yes
5558 > else
5559 >  qhull_cv_libqhull_h=no
5560 > fi
5561 >
5562 >
5563 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull" >&5
5564 > $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
5565 > if ${ac_cv_lib_qhull_qh_qhull+:} false; then :
5566 >  $as_echo_n "(cached) " >&6
5567 > else
5568 >  ac_check_lib_save_LIBS=$LIBS
5569 > LIBS="-lqhull  $LIBS"
5570 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5571 > /* end confdefs.h.  */
5572 >
5573 > /* Override any GCC internal prototype to avoid an error.
5574 >   Use char because int might match the return type of a GCC
5575 >   builtin and then its argument prototype would still apply.  */
5576 > #ifdef __cplusplus
5577 > extern "C"
5578 > #endif
5579 > char qh_qhull ();
5580 > int
5581 > main ()
5582 > {
5583 > return qh_qhull ();
5584 >  ;
5585 >  return 0;
5586 > }
5587 > _ACEOF
5588 > if ac_fn_c_try_link "$LINENO"; then :
5589 >  ac_cv_lib_qhull_qh_qhull=yes
5590 > else
5591 >  ac_cv_lib_qhull_qh_qhull=no
5592 > fi
5593 > rm -f core conftest.err conftest.$ac_objext \
5594 >    conftest$ac_exeext conftest.$ac_ext
5595 > LIBS=$ac_check_lib_save_LIBS
5596 > fi
5597 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull_qh_qhull" >&5
5598 > $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
5599 > if test "x$ac_cv_lib_qhull_qh_qhull" = xyes; then :
5600 >  qhull_cv_libqhull=yes
5601 > else
5602 >  qhull_cv_libqhull=no
5603 > fi
5604 >
5605 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull6" >&5
5606 > $as_echo_n "checking for qh_qhull in -lqhull6... " >&6; }
5607 > if ${ac_cv_lib_qhull6_qh_qhull+:} false; then :
5608 >  $as_echo_n "(cached) " >&6
5609 > else
5610 >  ac_check_lib_save_LIBS=$LIBS
5611 > LIBS="-lqhull6  $LIBS"
5612 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5613 > /* end confdefs.h.  */
5614 >
5615 > /* Override any GCC internal prototype to avoid an error.
5616 >   Use char because int might match the return type of a GCC
5617 >   builtin and then its argument prototype would still apply.  */
5618 > #ifdef __cplusplus
5619 > extern "C"
5620 > #endif
5621 > char qh_qhull ();
5622 > int
5623 > main ()
5624 > {
5625 > return qh_qhull ();
5626 >  ;
5627 >  return 0;
5628 > }
5629 > _ACEOF
5630 > if ac_fn_c_try_link "$LINENO"; then :
5631 >  ac_cv_lib_qhull6_qh_qhull=yes
5632 > else
5633 >  ac_cv_lib_qhull6_qh_qhull=no
5634 > fi
5635 > rm -f core conftest.err conftest.$ac_objext \
5636 >    conftest$ac_exeext conftest.$ac_ext
5637 > LIBS=$ac_check_lib_save_LIBS
5638 > fi
5639 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull6_qh_qhull" >&5
5640 > $as_echo "$ac_cv_lib_qhull6_qh_qhull" >&6; }
5641 > if test "x$ac_cv_lib_qhull6_qh_qhull" = xyes; then :
5642 >  qhull_cv_libqhull6=yes
5643 > else
5644 >  qhull_cv_libqhull6=no
5645 > fi
5646 >
5647 >        LDFLAGS="$QHULL_OLD_LDFLAGS"
5648 >        CFLAGS="$QHULL_OLD_CFLAGS"
5649 >        CPPFLAGS="$QHULL_OLD_CPPFLAGS"
5650 >        ac_ext=c
5651 > ac_cpp='$CPP $CPPFLAGS'
5652 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5653 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5654 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5655 >
5656 >
5657 >        if test "$qhull_cv_libqhull_h" = "yes" -a "$qhull_cv_libqhull" = "yes" -o "$qhull_cv_libqhull6" = "yes"; then
5658 >
5659 > $as_echo "#define HAVE_LIBQHULL_H 1" >>confdefs.h
5660 >
5661 >           if test "$qhull_cv_libqhull" = "yes"; then
5662 >
5663 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5664 >
5665 >                QHULL="-lqhull"
5666 >           fi
5667 >           if test "$qhull_cv_libqhull6" = "yes"; then
5668 >
5669 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5670 >
5671 >                QHULL="-lqhull6"
5672 >           fi
5673 >           USE_QHULL=yes
5674 >           QHULL_INC_DIR="${QHULL_HOME}/include"
5675 >           QHULL_LIB_DIR="${QHULL_HOME}/lib"
5676 >           { $as_echo "$as_me:${as_lineno-$LINENO}: result: Working qhull found, will proceed." >&5
5677 > $as_echo "Working qhull found, will proceed." >&6; }
5678 >        else
5679 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5680 > $as_echo "$as_me: WARNING: " >&2;}
5681 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
5682 > $as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
5683 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OpenMD to be able to deal with convex    " >&5
5684 > $as_echo "$as_me: WARNING: If you need OpenMD to be able to deal with convex    " >&2;}
5685 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
5686 > $as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
5687 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR                               " >&5
5688 > $as_echo "$as_me: WARNING: with --with-qhull=DIR                               " >&2;}
5689 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5690 > $as_echo "$as_me: WARNING: " >&2;}
5691 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OpenMD will still work without qhull installed.      " >&5
5692 > $as_echo "$as_me: WARNING: OpenMD will still work without qhull installed.      " >&2;}
5693 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5694 > $as_echo "$as_me: WARNING: " >&2;}
5695 >        fi
5696 >    fi
5697 > fi
5698 >
5699 >
5700 >
5701 >
5702 >
5703 > ac_ext=cpp
5704 > ac_cpp='$CXXCPP $CPPFLAGS'
5705 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5706 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5707 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5708 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
5709 > $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
5710 > if test -z "$CXXCPP"; then
5711 >  if ${ac_cv_prog_CXXCPP+:} false; then :
5712 >  $as_echo_n "(cached) " >&6
5713 > else
5714 >      # Double quotes because CXXCPP needs to be expanded
5715 >    for CXXCPP in "$CXX -E" "/lib/cpp"
5716 >    do
5717 >      ac_preproc_ok=false
5718 > for ac_cxx_preproc_warn_flag in '' yes
5719 > do
5720 >  # Use a header file that comes with gcc, so configuring glibc
5721 >  # with a fresh cross-compiler works.
5722 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5723 >  # <limits.h> exists even on freestanding compilers.
5724 >  # On the NeXT, cc -E runs the code through the compiler's parser,
5725 >  # not just through cpp. "Syntax error" is here to catch this case.
5726 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5727 > /* end confdefs.h.  */
5728 > #ifdef __STDC__
5729 > # include <limits.h>
5730 > #else
5731 > # include <assert.h>
5732 > #endif
5733 >                     Syntax error
5734 > _ACEOF
5735 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5736 >
5737 > else
5738 >  # Broken: fails on valid input.
5739 > continue
5740 > fi
5741 > rm -f conftest.err conftest.i conftest.$ac_ext
5742 >
5743 >  # OK, works on sane cases.  Now check whether nonexistent headers
5744 >  # can be detected and how.
5745 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5746 > /* end confdefs.h.  */
5747 > #include <ac_nonexistent.h>
5748 > _ACEOF
5749 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5750 >  # Broken: success on invalid input.
5751 > continue
5752 > else
5753 >  # Passes both tests.
5754 > ac_preproc_ok=:
5755 > break
5756 > fi
5757 > rm -f conftest.err conftest.i conftest.$ac_ext
5758 >
5759 > done
5760 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5761 > rm -f conftest.i conftest.err conftest.$ac_ext
5762 > if $ac_preproc_ok; then :
5763 >  break
5764 > fi
5765 >
5766 >    done
5767 >    ac_cv_prog_CXXCPP=$CXXCPP
5768 >
5769 > fi
5770 >  CXXCPP=$ac_cv_prog_CXXCPP
5771 > else
5772 >  ac_cv_prog_CXXCPP=$CXXCPP
5773 > fi
5774 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
5775 > $as_echo "$CXXCPP" >&6; }
5776 > ac_preproc_ok=false
5777 > for ac_cxx_preproc_warn_flag in '' yes
5778 > do
5779 >  # Use a header file that comes with gcc, so configuring glibc
5780 >  # with a fresh cross-compiler works.
5781 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5782 >  # <limits.h> exists even on freestanding compilers.
5783 >  # On the NeXT, cc -E runs the code through the compiler's parser,
5784 >  # not just through cpp. "Syntax error" is here to catch this case.
5785 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5786 > /* end confdefs.h.  */
5787 > #ifdef __STDC__
5788 > # include <limits.h>
5789 > #else
5790 > # include <assert.h>
5791 > #endif
5792 >                     Syntax error
5793 > _ACEOF
5794 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5795 >
5796 > else
5797 >  # Broken: fails on valid input.
5798 > continue
5799 > fi
5800 > rm -f conftest.err conftest.i conftest.$ac_ext
5801 >
5802 >  # OK, works on sane cases.  Now check whether nonexistent headers
5803 >  # can be detected and how.
5804 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5805 > /* end confdefs.h.  */
5806 > #include <ac_nonexistent.h>
5807 > _ACEOF
5808 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5809 >  # Broken: success on invalid input.
5810 > continue
5811 > else
5812 >  # Passes both tests.
5813 > ac_preproc_ok=:
5814 > break
5815 > fi
5816 > rm -f conftest.err conftest.i conftest.$ac_ext
5817 >
5818 > done
5819 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5820 > rm -f conftest.i conftest.err conftest.$ac_ext
5821 > if $ac_preproc_ok; then :
5822 >
5823 > else
5824 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5825 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5826 > as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
5827 > See \`config.log' for more details" "$LINENO" 5; }
5828 > fi
5829 >
5830 > ac_ext=cpp
5831 > ac_cpp='$CXXCPP $CPPFLAGS'
5832 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5833 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5834 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5835 >
5836 >
5837 > #
5838 > # Handle user hints
5839 > #
5840 >
5841 > # Check whether --with-openbabel was given.
5842 > if test "${with_openbabel+set}" = set; then :
5843 >  withval=$with_openbabel; openbabel_dir="$withval"
5844 > else
5845 >                openbabel_dir="not_set"
5846 > fi
5847 >
5848 > if test "$openbabel_dir" != "no"; then
5849 >
5850 > if test "$openbabel_dir" != "not_set" ; then
5851 >  if test -d "$openbabel_dir"
5852 >  then
5853 >    OPENBABEL_HOME="$openbabel_dir"
5854 >  else
5855 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
5856 > $as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
5857 >        OPENBABEL_HOME=/usr/local
5858 >        if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
5859 >        then
5860 >                OPENBABEL_HOME=/usr
5861 >        fi
5862 >  fi
5863 > fi
5864 > #
5865 > # Locate openbabel, if wanted
5866 > #
5867 > if test -n "${OPENBABEL_HOME}"
5868 > then
5869 >
5870 >        ac_ext=cpp
5871 > ac_cpp='$CXXCPP $CPPFLAGS'
5872 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5873 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5874 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5875 >
5876 >        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
5877 >        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
5878 >        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
5879 >        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
5880 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/babelconfig.h" "ac_cv_header_openbabel_babelconfig_h" "$ac_includes_default"
5881 > if test "x$ac_cv_header_openbabel_babelconfig_h" = xyes; then :
5882 >  openbabel_cv_openbabel_h=yes
5883 > else
5884 >  openbabel_cv_openbabel_h=no
5885 > fi
5886 >
5887 >
5888 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/obconversion.h" "ac_cv_header_openbabel_obconversion_h" "$ac_includes_default"
5889 > if test "x$ac_cv_header_openbabel_obconversion_h" = xyes; then :
5890 >  openbabel_cv_obconversion_h=yes
5891 > else
5892 >  openbabel_cv_obconversion_h=no
5893 > fi
5894 >
5895 >
5896 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5897 > /* end confdefs.h.  */
5898 >
5899 >
5900 > #include <openbabel/babelconfig.h>
5901 > #include <openbabel/obconversion.h>
5902 > using namespace std;
5903 > using namespace OpenBabel;
5904 >
5905 > int
5906 > main ()
5907 > {
5908 >
5909 > OBConversion Conv(&cin, &cout);
5910 >
5911 >
5912 >  ;
5913 >  return 0;
5914 > }
5915 > _ACEOF
5916 > if ac_fn_cxx_try_link "$LINENO"; then :
5917 >
5918 >                openbabel_lib_found="yes"
5919 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
5920 > $as_echo "found" >&6; }
5921 >
5922 > else
5923 >
5924 >                openbabel_lib_found="no"
5925 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
5926 > $as_echo "not found" >&6; }
5927 >
5928 >
5929 > fi
5930 > rm -f core conftest.err conftest.$ac_objext \
5931 >    conftest$ac_exeext conftest.$ac_ext
5932 >        ac_ext=c
5933 > ac_cpp='$CPP $CPPFLAGS'
5934 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5935 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5936 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5937 >
5938 >        LDFLAGS="$OPENBABEL_OLD_LDFLAGS"
5939 >        CPPFLAGS="$OPENBABEL_OLD_CPPFLAGS"
5940 >
5941 >        if test "$openbabel_lib_found" = "yes" -a "$openbabel_cv_openbabel_h" = "yes" -a "$openbabel_cv_obconversion_h" = "yes"; then
5942 >                USE_OPENBABEL=yes
5943 >                OPENBABEL_INC_DIR="${OPENBABEL_HOME}/include/openbabel-2.0"
5944 >                OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
5945 >                OPENBABEL_LIB="-lopenbabel"
5946 >        else
5947 >                { $as_echo "$as_me:${as_lineno-$LINENO}: checking openbabel in ${OPENBABEL_HOME}" >&5
5948 > $as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
5949 >                OPENBABEL_INC_DIR=
5950 >                OPENBABEL_LIB_DIR=
5951 >                OPENBABEL_LIB=
5952 >                USE_OPENBABEL=no
5953 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5954 > $as_echo "failed" >&6; }
5955 >                echo ""
5956 >                echo "*********************************************************"
5957 >                echo "* WARNING: Could not find a working openbabel-2.x       *"
5958 >                echo "* installation If you need OpenMD to be able to convert *"
5959 >                echo "* xyz or pdb files you need to specify a valid          *"
5960 >                echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
5961 >                echo "*                                                       *"
5962 >                echo "* OpenMD will still work without openbabel installed.   *"
5963 >                echo "*********************************************************"
5964 >                echo ""
5965 >        fi
5966 >
5967 >
5968 >
5969 >
5970 > fi
5971 > fi
5972 >
5973 >
5974 > # Checks for header files.
5975 > for ac_header in limits.h stdlib.h string.h sys/ioctl.h unistd.h
5976 > do :
5977 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
5978 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
5979 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
5980 >  cat >>confdefs.h <<_ACEOF
5981 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
5982   _ACEOF
5983  
5984   fi
5985  
5986 < { $as_echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
5987 < $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
5988 < if test "${ac_cv_header_time+set}" = set; then
5986 > done
5987 >
5988 >
5989 > # Checks for typedefs, structures, and compiler characteristics.
5990 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
5991 > $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
5992 > if ${ac_cv_header_stdbool_h+:} false; then :
5993    $as_echo_n "(cached) " >&6
5994   else
5995 <  cat >conftest.$ac_ext <<_ACEOF
10827 < /* confdefs.h.  */
10828 < _ACEOF
10829 < cat confdefs.h >>conftest.$ac_ext
10830 < cat >>conftest.$ac_ext <<_ACEOF
5995 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5996   /* end confdefs.h.  */
10832 – #include <sys/types.h>
10833 – #include <sys/time.h>
10834 – #include <time.h>
5997  
5998 < #ifdef FC_DUMMY_MAIN
5999 < #ifndef FC_DUMMY_MAIN_EQ_F77
6000 < #  ifdef __cplusplus
10839 <     extern "C"
10840 < #  endif
10841 <   int FC_DUMMY_MAIN() { return 1; }
5998 > #include <stdbool.h>
5999 > #ifndef bool
6000 > "error: bool is not defined"
6001   #endif
6002 + #ifndef false
6003 + "error: false is not defined"
6004   #endif
6005 + #if false
6006 + "error: false is not 0"
6007 + #endif
6008 + #ifndef true
6009 + "error: true is not defined"
6010 + #endif
6011 + #if true != 1
6012 + "error: true is not 1"
6013 + #endif
6014 + #ifndef __bool_true_false_are_defined
6015 + "error: __bool_true_false_are_defined is not defined"
6016 + #endif
6017 +
6018 +        struct s { _Bool s: 1; _Bool t; } s;
6019 +
6020 +        char a[true == 1 ? 1 : -1];
6021 +        char b[false == 0 ? 1 : -1];
6022 +        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
6023 +        char d[(bool) 0.5 == true ? 1 : -1];
6024 +        /* See body of main program for 'e'.  */
6025 +        char f[(_Bool) 0.0 == false ? 1 : -1];
6026 +        char g[true];
6027 +        char h[sizeof (_Bool)];
6028 +        char i[sizeof s.t];
6029 +        enum { j = false, k = true, l = false * true, m = true * 256 };
6030 +        /* The following fails for
6031 +           HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
6032 +        _Bool n[m];
6033 +        char o[sizeof n == m * sizeof n[0] ? 1 : -1];
6034 +        char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
6035 +        /* Catch a bug in an HP-UX C compiler.  See
6036 +           http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
6037 +           http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
6038 +         */
6039 +        _Bool q = true;
6040 +        _Bool *pq = &q;
6041 +
6042   int
6043   main ()
6044   {
6045 < if ((struct tm *) 0)
6046 < return 0;
6045 >
6046 >        bool e = &s;
6047 >        *pq |= q;
6048 >        *pq |= ! q;
6049 >        /* Refer to every declared value, to avoid compiler optimizations.  */
6050 >        return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
6051 >                + !m + !n + !o + !p + !q + !pq);
6052 >
6053    ;
6054    return 0;
6055   }
6056   _ACEOF
6057 < rm -f conftest.$ac_objext
6058 < if { (ac_try="$ac_compile"
10855 < case "(($ac_try" in
10856 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10857 <  *) ac_try_echo=$ac_try;;
10858 < esac
10859 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10860 < $as_echo "$ac_try_echo") >&5
10861 <  (eval "$ac_compile") 2>conftest.er1
10862 <  ac_status=$?
10863 <  grep -v '^ *+' conftest.er1 >conftest.err
10864 <  rm -f conftest.er1
10865 <  cat conftest.err >&5
10866 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10867 <  (exit $ac_status); } && {
10868 <         test -z "$ac_c_werror_flag" ||
10869 <         test ! -s conftest.err
10870 <       } && test -s conftest.$ac_objext; then
10871 <  ac_cv_header_time=yes
6057 > if ac_fn_c_try_compile "$LINENO"; then :
6058 >  ac_cv_header_stdbool_h=yes
6059   else
6060 <  $as_echo "$as_me: failed program was:" >&5
10874 < sed 's/^/| /' conftest.$ac_ext >&5
10875 <
10876 <        ac_cv_header_time=no
6060 >  ac_cv_header_stdbool_h=no
6061   fi
10878 –
6062   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6063   fi
6064 < { $as_echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
6065 < $as_echo "$ac_cv_header_time" >&6; }
6066 < if test $ac_cv_header_time = yes; then
6064 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
6065 > $as_echo "$ac_cv_header_stdbool_h" >&6; }
6066 > ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
6067 > if test "x$ac_cv_type__Bool" = xyes; then :
6068  
6069 < cat >>confdefs.h <<\_ACEOF
6070 < #define TIME_WITH_SYS_TIME 1
6069 > cat >>confdefs.h <<_ACEOF
6070 > #define HAVE__BOOL 1
6071   _ACEOF
6072  
6073 +
6074   fi
6075  
6076 + if test $ac_cv_header_stdbool_h = yes; then
6077  
6078 < # Checks for library functions.
6078 > $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
6079  
10894 – for ac_header in stdlib.h
10895 – do
10896 – as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
10897 – if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10898 –  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
10899 – $as_echo_n "checking for $ac_header... " >&6; }
10900 – if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10901 –  $as_echo_n "(cached) " >&6
6080   fi
6081 < ac_res=`eval 'as_val=${'$as_ac_Header'}
6082 <                 $as_echo "$as_val"'`
6083 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
6084 < $as_echo "$ac_res" >&6; }
6081 >
6082 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
6083 > $as_echo_n "checking for inline... " >&6; }
6084 > if ${ac_cv_c_inline+:} false; then :
6085 >  $as_echo_n "(cached) " >&6
6086   else
6087 <  # Is the header compilable?
6088 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
6089 < $as_echo_n "checking $ac_header usability... " >&6; }
10911 < cat >conftest.$ac_ext <<_ACEOF
10912 < /* confdefs.h.  */
10913 < _ACEOF
10914 < cat confdefs.h >>conftest.$ac_ext
10915 < cat >>conftest.$ac_ext <<_ACEOF
6087 >  ac_cv_c_inline=no
6088 > for ac_kw in inline __inline__ __inline; do
6089 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6090   /* end confdefs.h.  */
6091 < $ac_includes_default
6092 < #include <$ac_header>
6093 < _ACEOF
6094 < rm -f conftest.$ac_objext
6095 < if { (ac_try="$ac_compile"
10922 < case "(($ac_try" in
10923 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10924 <  *) ac_try_echo=$ac_try;;
10925 < esac
10926 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
10927 < $as_echo "$ac_try_echo") >&5
10928 <  (eval "$ac_compile") 2>conftest.er1
10929 <  ac_status=$?
10930 <  grep -v '^ *+' conftest.er1 >conftest.err
10931 <  rm -f conftest.er1
10932 <  cat conftest.err >&5
10933 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10934 <  (exit $ac_status); } && {
10935 <         test -z "$ac_c_werror_flag" ||
10936 <         test ! -s conftest.err
10937 <       } && test -s conftest.$ac_objext; then
10938 <  ac_header_compiler=yes
10939 < else
10940 <  $as_echo "$as_me: failed program was:" >&5
10941 < sed 's/^/| /' conftest.$ac_ext >&5
6091 > #ifndef __cplusplus
6092 > typedef int foo_t;
6093 > static $ac_kw foo_t static_foo () {return 0; }
6094 > $ac_kw foo_t foo () {return 0; }
6095 > #endif
6096  
6097 <        ac_header_compiler=no
6097 > _ACEOF
6098 > if ac_fn_c_try_compile "$LINENO"; then :
6099 >  ac_cv_c_inline=$ac_kw
6100   fi
10945 –
6101   rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6102 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
6103 < $as_echo "$ac_header_compiler" >&6; }
6102 >  test "$ac_cv_c_inline" != no && break
6103 > done
6104  
6105 < # Is the header present?
6106 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
6107 < $as_echo_n "checking $ac_header presence... " >&6; }
6108 < cat >conftest.$ac_ext <<_ACEOF
6109 < /* confdefs.h.  */
6105 > fi
6106 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
6107 > $as_echo "$ac_cv_c_inline" >&6; }
6108 >
6109 > case $ac_cv_c_inline in
6110 >  inline | yes) ;;
6111 >  *)
6112 >    case $ac_cv_c_inline in
6113 >      no) ac_val=;;
6114 >      *) ac_val=$ac_cv_c_inline;;
6115 >    esac
6116 >    cat >>confdefs.h <<_ACEOF
6117 > #ifndef __cplusplus
6118 > #define inline $ac_val
6119 > #endif
6120   _ACEOF
6121 < cat confdefs.h >>conftest.$ac_ext
10957 < cat >>conftest.$ac_ext <<_ACEOF
10958 < /* end confdefs.h.  */
10959 < #include <$ac_header>
10960 < _ACEOF
10961 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10962 < case "(($ac_try" in
10963 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10964 <  *) ac_try_echo=$ac_try;;
6121 >    ;;
6122   esac
6123 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
6124 < $as_echo "$ac_try_echo") >&5
6125 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
6126 <  ac_status=$?
10970 <  grep -v '^ *+' conftest.er1 >conftest.err
10971 <  rm -f conftest.er1
10972 <  cat conftest.err >&5
10973 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
10974 <  (exit $ac_status); } >/dev/null && {
10975 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10976 <         test ! -s conftest.err
10977 <       }; then
10978 <  ac_header_preproc=yes
6123 >
6124 > ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
6125 > if test "x$ac_cv_type_size_t" = xyes; then :
6126 >
6127   else
10980 –  $as_echo "$as_me: failed program was:" >&5
10981 – sed 's/^/| /' conftest.$ac_ext >&5
6128  
6129 <  ac_header_preproc=no
6129 > cat >>confdefs.h <<_ACEOF
6130 > #define size_t unsigned int
6131 > _ACEOF
6132 >
6133   fi
6134  
10986 – rm -f conftest.err conftest.$ac_ext
10987 – { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10988 – $as_echo "$ac_header_preproc" >&6; }
6135  
6136 < # So?  What about this header?
6137 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
6138 <  yes:no: )
6139 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
6140 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10995 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10996 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10997 <    ac_header_preproc=yes
10998 <    ;;
10999 <  no:yes:* )
11000 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11001 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11002 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11003 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11004 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11005 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11006 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11007 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11008 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11009 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11010 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11011 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11012 <    ( cat <<\_ASBOX
11013 < ## ------------------------------ ##
11014 < ## Report this to gezelter@nd.edu ##
11015 < ## ------------------------------ ##
11016 < _ASBOX
11017 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11018 <    ;;
11019 < esac
11020 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11021 < $as_echo_n "checking for $ac_header... " >&6; }
11022 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11023 <  $as_echo_n "(cached) " >&6
11024 < else
11025 <  eval "$as_ac_Header=\$ac_header_preproc"
11026 < fi
11027 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11028 <                 $as_echo "$as_val"'`
11029 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11030 < $as_echo "$ac_res" >&6; }
11031 <
11032 < fi
11033 < if test `eval 'as_val=${'$as_ac_Header'}
11034 <                 $as_echo "$as_val"'` = yes; then
6136 > # Checks for library functions.
6137 > for ac_header in stdlib.h
6138 > do :
6139 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6140 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6141    cat >>confdefs.h <<_ACEOF
6142 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6142 > #define HAVE_STDLIB_H 1
6143   _ACEOF
6144  
6145   fi
6146  
6147   done
6148  
6149 < { $as_echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
6149 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
6150   $as_echo_n "checking for GNU libc compatible malloc... " >&6; }
6151 < if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
6151 > if ${ac_cv_func_malloc_0_nonnull+:} false; then :
6152    $as_echo_n "(cached) " >&6
6153   else
6154 <  if test "$cross_compiling" = yes; then
6154 >  if test "$cross_compiling" = yes; then :
6155    ac_cv_func_malloc_0_nonnull=no
6156   else
6157 <  cat >conftest.$ac_ext <<_ACEOF
11052 < /* confdefs.h.  */
11053 < _ACEOF
11054 < cat confdefs.h >>conftest.$ac_ext
11055 < cat >>conftest.$ac_ext <<_ACEOF
6157 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6158   /* end confdefs.h.  */
6159   #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6160   # include <stdlib.h>
# Line 11060 | Line 6162 | char *malloc ();
6162   char *malloc ();
6163   #endif
6164  
11063 – #ifdef FC_DUMMY_MAIN
11064 – #ifndef FC_DUMMY_MAIN_EQ_F77
11065 – #  ifdef __cplusplus
11066 –     extern "C"
11067 – #  endif
11068 –   int FC_DUMMY_MAIN() { return 1; }
11069 – #endif
11070 – #endif
6165   int
6166   main ()
6167   {
# Line 11076 | Line 6170 | _ACEOF
6170    return 0;
6171   }
6172   _ACEOF
6173 < rm -f conftest$ac_exeext
11080 < if { (ac_try="$ac_link"
11081 < case "(($ac_try" in
11082 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11083 <  *) ac_try_echo=$ac_try;;
11084 < esac
11085 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11086 < $as_echo "$ac_try_echo") >&5
11087 <  (eval "$ac_link") 2>&5
11088 <  ac_status=$?
11089 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11090 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11091 <  { (case "(($ac_try" in
11092 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11093 <  *) ac_try_echo=$ac_try;;
11094 < esac
11095 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11096 < $as_echo "$ac_try_echo") >&5
11097 <  (eval "$ac_try") 2>&5
11098 <  ac_status=$?
11099 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11100 <  (exit $ac_status); }; }; then
6173 > if ac_fn_c_try_run "$LINENO"; then :
6174    ac_cv_func_malloc_0_nonnull=yes
6175   else
6176 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11104 < $as_echo "$as_me: failed program was:" >&5
11105 < sed 's/^/| /' conftest.$ac_ext >&5
11106 <
11107 < ( exit $ac_status )
11108 < ac_cv_func_malloc_0_nonnull=no
6176 >  ac_cv_func_malloc_0_nonnull=no
6177   fi
6178 < rm -rf conftest.dSYM
6179 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6178 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6179 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6180   fi
6181  
11114 –
6182   fi
6183 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
6183 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
6184   $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
6185 < if test $ac_cv_func_malloc_0_nonnull = yes; then
6185 > if test $ac_cv_func_malloc_0_nonnull = yes; then :
6186  
6187 < cat >>confdefs.h <<\_ACEOF
11121 < #define HAVE_MALLOC 1
11122 < _ACEOF
6187 > $as_echo "#define HAVE_MALLOC 1" >>confdefs.h
6188  
6189   else
6190 <  cat >>confdefs.h <<\_ACEOF
11126 < #define HAVE_MALLOC 0
11127 < _ACEOF
6190 >  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
6191  
6192     case " $LIBOBJS " in
6193    *" malloc.$ac_objext "* ) ;;
# Line 11133 | Line 6196 | esac
6196   esac
6197  
6198  
6199 < cat >>confdefs.h <<\_ACEOF
11137 < #define malloc rpl_malloc
11138 < _ACEOF
6199 > $as_echo "#define malloc rpl_malloc" >>confdefs.h
6200  
6201   fi
6202  
6203  
11143 –
11144 –
6204   for ac_header in stdlib.h
6205 < do
6206 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6207 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
6208 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
6209 < $as_echo_n "checking for $ac_header... " >&6; }
11151 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11152 <  $as_echo_n "(cached) " >&6
11153 < fi
11154 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11155 <                 $as_echo "$as_val"'`
11156 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11157 < $as_echo "$ac_res" >&6; }
11158 < else
11159 <  # Is the header compilable?
11160 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11161 < $as_echo_n "checking $ac_header usability... " >&6; }
11162 < cat >conftest.$ac_ext <<_ACEOF
11163 < /* confdefs.h.  */
6205 > do :
6206 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6207 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6208 >  cat >>confdefs.h <<_ACEOF
6209 > #define HAVE_STDLIB_H 1
6210   _ACEOF
11165 – cat confdefs.h >>conftest.$ac_ext
11166 – cat >>conftest.$ac_ext <<_ACEOF
11167 – /* end confdefs.h.  */
11168 – $ac_includes_default
11169 – #include <$ac_header>
11170 – _ACEOF
11171 – rm -f conftest.$ac_objext
11172 – if { (ac_try="$ac_compile"
11173 – case "(($ac_try" in
11174 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11175 –  *) ac_try_echo=$ac_try;;
11176 – esac
11177 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11178 – $as_echo "$ac_try_echo") >&5
11179 –  (eval "$ac_compile") 2>conftest.er1
11180 –  ac_status=$?
11181 –  grep -v '^ *+' conftest.er1 >conftest.err
11182 –  rm -f conftest.er1
11183 –  cat conftest.err >&5
11184 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11185 –  (exit $ac_status); } && {
11186 –         test -z "$ac_c_werror_flag" ||
11187 –         test ! -s conftest.err
11188 –       } && test -s conftest.$ac_objext; then
11189 –  ac_header_compiler=yes
11190 – else
11191 –  $as_echo "$as_me: failed program was:" >&5
11192 – sed 's/^/| /' conftest.$ac_ext >&5
6211  
11194 –        ac_header_compiler=no
6212   fi
6213  
6214 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11198 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11199 < $as_echo "$ac_header_compiler" >&6; }
6214 > done
6215  
6216 < # Is the header present?
6217 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
6218 < $as_echo_n "checking $ac_header presence... " >&6; }
6219 < cat >conftest.$ac_ext <<_ACEOF
11205 < /* confdefs.h.  */
11206 < _ACEOF
11207 < cat confdefs.h >>conftest.$ac_ext
11208 < cat >>conftest.$ac_ext <<_ACEOF
11209 < /* end confdefs.h.  */
11210 < #include <$ac_header>
11211 < _ACEOF
11212 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11213 < case "(($ac_try" in
11214 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11215 <  *) ac_try_echo=$ac_try;;
11216 < esac
11217 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11218 < $as_echo "$ac_try_echo") >&5
11219 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11220 <  ac_status=$?
11221 <  grep -v '^ *+' conftest.er1 >conftest.err
11222 <  rm -f conftest.er1
11223 <  cat conftest.err >&5
11224 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11225 <  (exit $ac_status); } >/dev/null && {
11226 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11227 <         test ! -s conftest.err
11228 <       }; then
11229 <  ac_header_preproc=yes
6216 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
6217 > $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
6218 > if ${ac_cv_func_realloc_0_nonnull+:} false; then :
6219 >  $as_echo_n "(cached) " >&6
6220   else
6221 <  $as_echo "$as_me: failed program was:" >&5
6222 < sed 's/^/| /' conftest.$ac_ext >&5
6223 <
6224 <  ac_header_preproc=no
11235 < fi
11236 <
11237 < rm -f conftest.err conftest.$ac_ext
11238 < { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11239 < $as_echo "$ac_header_preproc" >&6; }
11240 <
11241 < # So?  What about this header?
11242 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11243 <  yes:no: )
11244 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11245 < $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11246 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11247 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11248 <    ac_header_preproc=yes
11249 <    ;;
11250 <  no:yes:* )
11251 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11252 < $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11253 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11254 < $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11255 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11256 < $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11257 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11258 < $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11259 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11260 < $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11261 <    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11262 < $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11263 <    ( cat <<\_ASBOX
11264 < ## ------------------------------ ##
11265 < ## Report this to gezelter@nd.edu ##
11266 < ## ------------------------------ ##
11267 < _ASBOX
11268 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11269 <    ;;
11270 < esac
11271 < { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11272 < $as_echo_n "checking for $ac_header... " >&6; }
11273 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11274 <  $as_echo_n "(cached) " >&6
11275 < else
11276 <  eval "$as_ac_Header=\$ac_header_preproc"
11277 < fi
11278 < ac_res=`eval 'as_val=${'$as_ac_Header'}
11279 <                 $as_echo "$as_val"'`
11280 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11281 < $as_echo "$ac_res" >&6; }
11282 <
11283 < fi
11284 < if test `eval 'as_val=${'$as_ac_Header'}
11285 <                 $as_echo "$as_val"'` = yes; then
11286 <  cat >>confdefs.h <<_ACEOF
11287 < #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
11288 < _ACEOF
11289 <
11290 < fi
11291 <
11292 < done
11293 <
11294 < { $as_echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
11295 < $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
11296 < if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
11297 <  $as_echo_n "(cached) " >&6
11298 < else
11299 <  if test "$cross_compiling" = yes; then
11300 <  ac_cv_func_realloc_0_nonnull=no
11301 < else
11302 <  cat >conftest.$ac_ext <<_ACEOF
11303 < /* confdefs.h.  */
11304 < _ACEOF
11305 < cat confdefs.h >>conftest.$ac_ext
11306 < cat >>conftest.$ac_ext <<_ACEOF
6221 >  if test "$cross_compiling" = yes; then :
6222 >  ac_cv_func_realloc_0_nonnull=no
6223 > else
6224 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6225   /* end confdefs.h.  */
6226   #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6227   # include <stdlib.h>
# Line 11311 | Line 6229 | char *realloc ();
6229   char *realloc ();
6230   #endif
6231  
11314 – #ifdef FC_DUMMY_MAIN
11315 – #ifndef FC_DUMMY_MAIN_EQ_F77
11316 – #  ifdef __cplusplus
11317 –     extern "C"
11318 – #  endif
11319 –   int FC_DUMMY_MAIN() { return 1; }
11320 – #endif
11321 – #endif
6232   int
6233   main ()
6234   {
# Line 11327 | Line 6237 | _ACEOF
6237    return 0;
6238   }
6239   _ACEOF
6240 < rm -f conftest$ac_exeext
11331 < if { (ac_try="$ac_link"
11332 < case "(($ac_try" in
11333 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11334 <  *) ac_try_echo=$ac_try;;
11335 < esac
11336 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11337 < $as_echo "$ac_try_echo") >&5
11338 <  (eval "$ac_link") 2>&5
11339 <  ac_status=$?
11340 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11341 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11342 <  { (case "(($ac_try" in
11343 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11344 <  *) ac_try_echo=$ac_try;;
11345 < esac
11346 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11347 < $as_echo "$ac_try_echo") >&5
11348 <  (eval "$ac_try") 2>&5
11349 <  ac_status=$?
11350 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11351 <  (exit $ac_status); }; }; then
6240 > if ac_fn_c_try_run "$LINENO"; then :
6241    ac_cv_func_realloc_0_nonnull=yes
6242   else
6243 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11355 < $as_echo "$as_me: failed program was:" >&5
11356 < sed 's/^/| /' conftest.$ac_ext >&5
11357 <
11358 < ( exit $ac_status )
11359 < ac_cv_func_realloc_0_nonnull=no
6243 >  ac_cv_func_realloc_0_nonnull=no
6244   fi
6245 < rm -rf conftest.dSYM
6246 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6245 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6246 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6247   fi
6248  
11365 –
6249   fi
6250 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
6250 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
6251   $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
6252 < if test $ac_cv_func_realloc_0_nonnull = yes; then
6252 > if test $ac_cv_func_realloc_0_nonnull = yes; then :
6253  
6254 < cat >>confdefs.h <<\_ACEOF
11372 < #define HAVE_REALLOC 1
11373 < _ACEOF
6254 > $as_echo "#define HAVE_REALLOC 1" >>confdefs.h
6255  
6256   else
6257 <  cat >>confdefs.h <<\_ACEOF
11377 < #define HAVE_REALLOC 0
11378 < _ACEOF
6257 >  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
6258  
6259     case " $LIBOBJS " in
6260    *" realloc.$ac_objext "* ) ;;
# Line 11384 | Line 6263 | esac
6263   esac
6264  
6265  
6266 < cat >>confdefs.h <<\_ACEOF
11388 < #define realloc rpl_realloc
11389 < _ACEOF
6266 > $as_echo "#define realloc rpl_realloc" >>confdefs.h
6267  
6268   fi
6269  
6270  
6271 <
6272 <
6273 <
11397 < for ac_header in sys/select.h sys/socket.h
11398 < do
11399 < as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
11400 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11401 <  { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11402 < $as_echo_n "checking for $ac_header... " >&6; }
11403 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
6271 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
6272 > $as_echo_n "checking for working strtod... " >&6; }
6273 > if ${ac_cv_func_strtod+:} false; then :
6274    $as_echo_n "(cached) " >&6
11405 – fi
11406 – ac_res=`eval 'as_val=${'$as_ac_Header'}
11407 –                 $as_echo "$as_val"'`
11408 –               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11409 – $as_echo "$ac_res" >&6; }
6275   else
6276 <  # Is the header compilable?
6277 < { $as_echo "$as_me:$LINENO: checking $ac_header usability" >&5
11413 < $as_echo_n "checking $ac_header usability... " >&6; }
11414 < cat >conftest.$ac_ext <<_ACEOF
11415 < /* confdefs.h.  */
11416 < _ACEOF
11417 < cat confdefs.h >>conftest.$ac_ext
11418 < cat >>conftest.$ac_ext <<_ACEOF
11419 < /* end confdefs.h.  */
11420 < $ac_includes_default
11421 < #include <$ac_header>
11422 < _ACEOF
11423 < rm -f conftest.$ac_objext
11424 < if { (ac_try="$ac_compile"
11425 < case "(($ac_try" in
11426 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11427 <  *) ac_try_echo=$ac_try;;
11428 < esac
11429 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11430 < $as_echo "$ac_try_echo") >&5
11431 <  (eval "$ac_compile") 2>conftest.er1
11432 <  ac_status=$?
11433 <  grep -v '^ *+' conftest.er1 >conftest.err
11434 <  rm -f conftest.er1
11435 <  cat conftest.err >&5
11436 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11437 <  (exit $ac_status); } && {
11438 <         test -z "$ac_c_werror_flag" ||
11439 <         test ! -s conftest.err
11440 <       } && test -s conftest.$ac_objext; then
11441 <  ac_header_compiler=yes
6276 >  if test "$cross_compiling" = yes; then :
6277 >  ac_cv_func_strtod=no
6278   else
6279 <  $as_echo "$as_me: failed program was:" >&5
11444 < sed 's/^/| /' conftest.$ac_ext >&5
11445 <
11446 <        ac_header_compiler=no
11447 < fi
11448 <
11449 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11450 < { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11451 < $as_echo "$ac_header_compiler" >&6; }
11452 <
11453 < # Is the header present?
11454 < { $as_echo "$as_me:$LINENO: checking $ac_header presence" >&5
11455 < $as_echo_n "checking $ac_header presence... " >&6; }
11456 < cat >conftest.$ac_ext <<_ACEOF
11457 < /* confdefs.h.  */
11458 < _ACEOF
11459 < cat confdefs.h >>conftest.$ac_ext
11460 < cat >>conftest.$ac_ext <<_ACEOF
6279 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6280   /* end confdefs.h.  */
11462 – #include <$ac_header>
11463 – _ACEOF
11464 – if { (ac_try="$ac_cpp conftest.$ac_ext"
11465 – case "(($ac_try" in
11466 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11467 –  *) ac_try_echo=$ac_try;;
11468 – esac
11469 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11470 – $as_echo "$ac_try_echo") >&5
11471 –  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11472 –  ac_status=$?
11473 –  grep -v '^ *+' conftest.er1 >conftest.err
11474 –  rm -f conftest.er1
11475 –  cat conftest.err >&5
11476 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11477 –  (exit $ac_status); } >/dev/null && {
11478 –         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11479 –         test ! -s conftest.err
11480 –       }; then
11481 –  ac_header_preproc=yes
11482 – else
11483 –  $as_echo "$as_me: failed program was:" >&5
11484 – sed 's/^/| /' conftest.$ac_ext >&5
6281  
11486 –  ac_header_preproc=no
11487 – fi
11488 –
11489 – rm -f conftest.err conftest.$ac_ext
11490 – { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11491 – $as_echo "$ac_header_preproc" >&6; }
11492 –
11493 – # So?  What about this header?
11494 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11495 –  yes:no: )
11496 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11497 – $as_echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11498 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11499 – $as_echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11500 –    ac_header_preproc=yes
11501 –    ;;
11502 –  no:yes:* )
11503 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11504 – $as_echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11505 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11506 – $as_echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11507 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11508 – $as_echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11509 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11510 – $as_echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11511 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11512 – $as_echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11513 –    { $as_echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11514 – $as_echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11515 –    ( cat <<\_ASBOX
11516 – ## ------------------------------ ##
11517 – ## Report this to gezelter@nd.edu ##
11518 – ## ------------------------------ ##
11519 – _ASBOX
11520 –     ) | sed "s/^/$as_me: WARNING:     /" >&2
11521 –    ;;
11522 – esac
11523 – { $as_echo "$as_me:$LINENO: checking for $ac_header" >&5
11524 – $as_echo_n "checking for $ac_header... " >&6; }
11525 – if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11526 –  $as_echo_n "(cached) " >&6
11527 – else
11528 –  eval "$as_ac_Header=\$ac_header_preproc"
11529 – fi
11530 – ac_res=`eval 'as_val=${'$as_ac_Header'}
11531 –                 $as_echo "$as_val"'`
11532 –               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
11533 – $as_echo "$ac_res" >&6; }
11534 –
11535 – fi
11536 – if test `eval 'as_val=${'$as_ac_Header'}
11537 –                 $as_echo "$as_val"'` = yes; then
11538 –  cat >>confdefs.h <<_ACEOF
11539 – #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
11540 – _ACEOF
11541 –
11542 – fi
11543 –
11544 – done
11545 –
11546 – { $as_echo "$as_me:$LINENO: checking types of arguments for select" >&5
11547 – $as_echo_n "checking types of arguments for select... " >&6; }
11548 – if test "${ac_cv_func_select_args+set}" = set; then
11549 –  $as_echo_n "(cached) " >&6
11550 – else
11551 –  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
11552 – for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
11553 –  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
11554 –   cat >conftest.$ac_ext <<_ACEOF
11555 – /* confdefs.h.  */
11556 – _ACEOF
11557 – cat confdefs.h >>conftest.$ac_ext
11558 – cat >>conftest.$ac_ext <<_ACEOF
11559 – /* end confdefs.h.  */
6282   $ac_includes_default
11561 – #ifdef HAVE_SYS_SELECT_H
11562 – # include <sys/select.h>
11563 – #endif
11564 – #ifdef HAVE_SYS_SOCKET_H
11565 – # include <sys/socket.h>
11566 – #endif
11567 –
11568 – #ifdef FC_DUMMY_MAIN
11569 – #ifndef FC_DUMMY_MAIN_EQ_F77
11570 – #  ifdef __cplusplus
11571 –     extern "C"
11572 – #  endif
11573 –   int FC_DUMMY_MAIN() { return 1; }
11574 – #endif
11575 – #endif
11576 – int
11577 – main ()
11578 – {
11579 – extern int select ($ac_arg1,
11580 –                                            $ac_arg234, $ac_arg234, $ac_arg234,
11581 –                                            $ac_arg5);
11582 –  ;
11583 –  return 0;
11584 – }
11585 – _ACEOF
11586 – rm -f conftest.$ac_objext
11587 – if { (ac_try="$ac_compile"
11588 – case "(($ac_try" in
11589 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11590 –  *) ac_try_echo=$ac_try;;
11591 – esac
11592 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11593 – $as_echo "$ac_try_echo") >&5
11594 –  (eval "$ac_compile") 2>conftest.er1
11595 –  ac_status=$?
11596 –  grep -v '^ *+' conftest.er1 >conftest.err
11597 –  rm -f conftest.er1
11598 –  cat conftest.err >&5
11599 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11600 –  (exit $ac_status); } && {
11601 –         test -z "$ac_c_werror_flag" ||
11602 –         test ! -s conftest.err
11603 –       } && test -s conftest.$ac_objext; then
11604 –  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
11605 – else
11606 –  $as_echo "$as_me: failed program was:" >&5
11607 – sed 's/^/| /' conftest.$ac_ext >&5
11608 –
11609 –
11610 – fi
11611 –
11612 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11613 –  done
11614 – done
11615 – done
11616 – # Provide a safe default value.
11617 – : ${ac_cv_func_select_args='int,int *,struct timeval *'}
11618 –
11619 – fi
11620 – { $as_echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
11621 – $as_echo "$ac_cv_func_select_args" >&6; }
11622 – ac_save_IFS=$IFS; IFS=','
11623 – set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
11624 – IFS=$ac_save_IFS
11625 – shift
11626 –
11627 – cat >>confdefs.h <<_ACEOF
11628 – #define SELECT_TYPE_ARG1 $1
11629 – _ACEOF
11630 –
11631 –
11632 – cat >>confdefs.h <<_ACEOF
11633 – #define SELECT_TYPE_ARG234 ($2)
11634 – _ACEOF
11635 –
11636 –
11637 – cat >>confdefs.h <<_ACEOF
11638 – #define SELECT_TYPE_ARG5 ($3)
11639 – _ACEOF
11640 –
11641 – rm -f conftest*
11642 –
11643 – { $as_echo "$as_me:$LINENO: checking for working strtod" >&5
11644 – $as_echo_n "checking for working strtod... " >&6; }
11645 – if test "${ac_cv_func_strtod+set}" = set; then
11646 –  $as_echo_n "(cached) " >&6
11647 – else
11648 –  if test "$cross_compiling" = yes; then
11649 –  ac_cv_func_strtod=no
11650 – else
11651 –  cat >conftest.$ac_ext <<_ACEOF
11652 – /* confdefs.h.  */
11653 – _ACEOF
11654 – cat confdefs.h >>conftest.$ac_ext
11655 – cat >>conftest.$ac_ext <<_ACEOF
11656 – /* end confdefs.h.  */
11657 –
11658 – $ac_includes_default
6283   #ifndef strtod
6284   double strtod ();
6285   #endif
# Line 11685 | Line 6309 | _ACEOF
6309   }
6310  
6311   _ACEOF
6312 < rm -f conftest$ac_exeext
11689 < if { (ac_try="$ac_link"
11690 < case "(($ac_try" in
11691 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11692 <  *) ac_try_echo=$ac_try;;
11693 < esac
11694 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11695 < $as_echo "$ac_try_echo") >&5
11696 <  (eval "$ac_link") 2>&5
11697 <  ac_status=$?
11698 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11699 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
11700 <  { (case "(($ac_try" in
11701 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11702 <  *) ac_try_echo=$ac_try;;
11703 < esac
11704 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11705 < $as_echo "$ac_try_echo") >&5
11706 <  (eval "$ac_try") 2>&5
11707 <  ac_status=$?
11708 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11709 <  (exit $ac_status); }; }; then
6312 > if ac_fn_c_try_run "$LINENO"; then :
6313    ac_cv_func_strtod=yes
6314   else
6315 <  $as_echo "$as_me: program exited with status $ac_status" >&5
11713 < $as_echo "$as_me: failed program was:" >&5
11714 < sed 's/^/| /' conftest.$ac_ext >&5
11715 <
11716 < ( exit $ac_status )
11717 < ac_cv_func_strtod=no
6315 >  ac_cv_func_strtod=no
6316   fi
6317 < rm -rf conftest.dSYM
6318 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6317 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6318 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6319   fi
6320  
11723 –
6321   fi
6322 < { $as_echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
6322 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
6323   $as_echo "$ac_cv_func_strtod" >&6; }
6324   if test $ac_cv_func_strtod = no; then
6325    case " $LIBOBJS " in
# Line 11730 | Line 6327 | esac
6327    *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
6328   ;;
6329   esac
11733 –
11734 – { $as_echo "$as_me:$LINENO: checking for pow" >&5
11735 – $as_echo_n "checking for pow... " >&6; }
11736 – if test "${ac_cv_func_pow+set}" = set; then
11737 –  $as_echo_n "(cached) " >&6
11738 – else
11739 –  cat >conftest.$ac_ext <<_ACEOF
11740 – /* confdefs.h.  */
11741 – _ACEOF
11742 – cat confdefs.h >>conftest.$ac_ext
11743 – cat >>conftest.$ac_ext <<_ACEOF
11744 – /* end confdefs.h.  */
11745 – /* Define pow to an innocuous variant, in case <limits.h> declares pow.
11746 –   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11747 – #define pow innocuous_pow
11748 –
11749 – /* System header to define __stub macros and hopefully few prototypes,
11750 –    which can conflict with char pow (); below.
11751 –    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11752 –    <limits.h> exists even on freestanding compilers.  */
11753 –
11754 – #ifdef __STDC__
11755 – # include <limits.h>
11756 – #else
11757 – # include <assert.h>
11758 – #endif
11759 –
11760 – #undef pow
11761 –
11762 – /* Override any GCC internal prototype to avoid an error.
11763 –   Use char because int might match the return type of a GCC
11764 –   builtin and then its argument prototype would still apply.  */
11765 – #ifdef __cplusplus
11766 – extern "C"
11767 – #endif
11768 – char pow ();
11769 – /* The GNU C library defines this for functions which it implements
11770 –    to always fail with ENOSYS.  Some functions are actually named
11771 –    something starting with __ and the normal name is an alias.  */
11772 – #if defined __stub_pow || defined __stub___pow
11773 – choke me
11774 – #endif
11775 –
11776 – #ifdef FC_DUMMY_MAIN
11777 – #ifndef FC_DUMMY_MAIN_EQ_F77
11778 – #  ifdef __cplusplus
11779 –     extern "C"
11780 – #  endif
11781 –   int FC_DUMMY_MAIN() { return 1; }
11782 – #endif
11783 – #endif
11784 – int
11785 – main ()
11786 – {
11787 – return pow ();
11788 –  ;
11789 –  return 0;
11790 – }
11791 – _ACEOF
11792 – rm -f conftest.$ac_objext conftest$ac_exeext
11793 – if { (ac_try="$ac_link"
11794 – case "(($ac_try" in
11795 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11796 –  *) ac_try_echo=$ac_try;;
11797 – esac
11798 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11799 – $as_echo "$ac_try_echo") >&5
11800 –  (eval "$ac_link") 2>conftest.er1
11801 –  ac_status=$?
11802 –  grep -v '^ *+' conftest.er1 >conftest.err
11803 –  rm -f conftest.er1
11804 –  cat conftest.err >&5
11805 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11806 –  (exit $ac_status); } && {
11807 –         test -z "$ac_c_werror_flag" ||
11808 –         test ! -s conftest.err
11809 –       } && test -s conftest$ac_exeext && {
11810 –         test "$cross_compiling" = yes ||
11811 –         $as_test_x conftest$ac_exeext
11812 –       }; then
11813 –  ac_cv_func_pow=yes
11814 – else
11815 –  $as_echo "$as_me: failed program was:" >&5
11816 – sed 's/^/| /' conftest.$ac_ext >&5
6330  
6331 <        ac_cv_func_pow=no
6332 < fi
6331 > ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
6332 > if test "x$ac_cv_func_pow" = xyes; then :
6333  
11821 – rm -rf conftest.dSYM
11822 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11823 –      conftest$ac_exeext conftest.$ac_ext
6334   fi
11825 – { $as_echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11826 – $as_echo "$ac_cv_func_pow" >&6; }
6335  
6336   if test $ac_cv_func_pow = no; then
6337 <  { $as_echo "$as_me:$LINENO: checking for pow in -lm" >&5
6337 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
6338   $as_echo_n "checking for pow in -lm... " >&6; }
6339 < if test "${ac_cv_lib_m_pow+set}" = set; then
6339 > if ${ac_cv_lib_m_pow+:} false; then :
6340    $as_echo_n "(cached) " >&6
6341   else
6342    ac_check_lib_save_LIBS=$LIBS
6343   LIBS="-lm  $LIBS"
6344 < cat >conftest.$ac_ext <<_ACEOF
11837 < /* confdefs.h.  */
11838 < _ACEOF
11839 < cat confdefs.h >>conftest.$ac_ext
11840 < cat >>conftest.$ac_ext <<_ACEOF
6344 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6345   /* end confdefs.h.  */
6346  
6347   /* Override any GCC internal prototype to avoid an error.
# Line 11847 | Line 6351 | char pow ();
6351   extern "C"
6352   #endif
6353   char pow ();
11850 – #ifdef FC_DUMMY_MAIN
11851 – #ifndef FC_DUMMY_MAIN_EQ_F77
11852 – #  ifdef __cplusplus
11853 –     extern "C"
11854 – #  endif
11855 –   int FC_DUMMY_MAIN() { return 1; }
11856 – #endif
11857 – #endif
6354   int
6355   main ()
6356   {
# Line 11863 | Line 6359 | _ACEOF
6359    return 0;
6360   }
6361   _ACEOF
6362 < rm -f conftest.$ac_objext conftest$ac_exeext
11867 < if { (ac_try="$ac_link"
11868 < case "(($ac_try" in
11869 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11870 <  *) ac_try_echo=$ac_try;;
11871 < esac
11872 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
11873 < $as_echo "$ac_try_echo") >&5
11874 <  (eval "$ac_link") 2>conftest.er1
11875 <  ac_status=$?
11876 <  grep -v '^ *+' conftest.er1 >conftest.err
11877 <  rm -f conftest.er1
11878 <  cat conftest.err >&5
11879 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
11880 <  (exit $ac_status); } && {
11881 <         test -z "$ac_c_werror_flag" ||
11882 <         test ! -s conftest.err
11883 <       } && test -s conftest$ac_exeext && {
11884 <         test "$cross_compiling" = yes ||
11885 <         $as_test_x conftest$ac_exeext
11886 <       }; then
6362 > if ac_fn_c_try_link "$LINENO"; then :
6363    ac_cv_lib_m_pow=yes
6364   else
6365 <  $as_echo "$as_me: failed program was:" >&5
11890 < sed 's/^/| /' conftest.$ac_ext >&5
11891 <
11892 <        ac_cv_lib_m_pow=no
6365 >  ac_cv_lib_m_pow=no
6366   fi
6367 <
6368 < rm -rf conftest.dSYM
11896 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11897 <      conftest$ac_exeext conftest.$ac_ext
6367 > rm -f core conftest.err conftest.$ac_objext \
6368 >    conftest$ac_exeext conftest.$ac_ext
6369   LIBS=$ac_check_lib_save_LIBS
6370   fi
6371 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
6371 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
6372   $as_echo "$ac_cv_lib_m_pow" >&6; }
6373 < if test $ac_cv_lib_m_pow = yes; then
6373 > if test "x$ac_cv_lib_m_pow" = xyes; then :
6374    POW_LIB=-lm
6375   else
6376 <  { $as_echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
6376 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
6377   $as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
6378   fi
6379  
# Line 11910 | Line 6381 | fi
6381  
6382   fi
6383  
6384 <
6385 <
6386 <
6387 <
6388 <
11918 <
11919 <
11920 <
11921 <
11922 <
11923 <
11924 <
11925 <
11926 <
11927 <
11928 <
11929 <
11930 <
11931 <
11932 <
11933 <
11934 < 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
11935 < do
11936 < as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
11937 < { $as_echo "$as_me:$LINENO: checking for $ac_func" >&5
11938 < $as_echo_n "checking for $ac_func... " >&6; }
11939 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11940 <  $as_echo_n "(cached) " >&6
11941 < else
11942 <  cat >conftest.$ac_ext <<_ACEOF
11943 < /* confdefs.h.  */
11944 < _ACEOF
11945 < cat confdefs.h >>conftest.$ac_ext
11946 < cat >>conftest.$ac_ext <<_ACEOF
11947 < /* end confdefs.h.  */
11948 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11949 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11950 < #define $ac_func innocuous_$ac_func
11951 <
11952 < /* System header to define __stub macros and hopefully few prototypes,
11953 <    which can conflict with char $ac_func (); below.
11954 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11955 <    <limits.h> exists even on freestanding compilers.  */
11956 <
11957 < #ifdef __STDC__
11958 < # include <limits.h>
11959 < #else
11960 < # include <assert.h>
11961 < #endif
11962 <
11963 < #undef $ac_func
11964 <
11965 < /* Override any GCC internal prototype to avoid an error.
11966 <   Use char because int might match the return type of a GCC
11967 <   builtin and then its argument prototype would still apply.  */
11968 < #ifdef __cplusplus
11969 < extern "C"
11970 < #endif
11971 < char $ac_func ();
11972 < /* The GNU C library defines this for functions which it implements
11973 <    to always fail with ENOSYS.  Some functions are actually named
11974 <    something starting with __ and the normal name is an alias.  */
11975 < #if defined __stub_$ac_func || defined __stub___$ac_func
11976 < choke me
11977 < #endif
11978 <
11979 < #ifdef FC_DUMMY_MAIN
11980 < #ifndef FC_DUMMY_MAIN_EQ_F77
11981 < #  ifdef __cplusplus
11982 <     extern "C"
11983 < #  endif
11984 <   int FC_DUMMY_MAIN() { return 1; }
11985 < #endif
11986 < #endif
11987 < int
11988 < main ()
11989 < {
11990 < return $ac_func ();
11991 <  ;
11992 <  return 0;
11993 < }
11994 < _ACEOF
11995 < rm -f conftest.$ac_objext conftest$ac_exeext
11996 < if { (ac_try="$ac_link"
11997 < case "(($ac_try" in
11998 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11999 <  *) ac_try_echo=$ac_try;;
12000 < esac
12001 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12002 < $as_echo "$ac_try_echo") >&5
12003 <  (eval "$ac_link") 2>conftest.er1
12004 <  ac_status=$?
12005 <  grep -v '^ *+' conftest.er1 >conftest.err
12006 <  rm -f conftest.er1
12007 <  cat conftest.err >&5
12008 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12009 <  (exit $ac_status); } && {
12010 <         test -z "$ac_c_werror_flag" ||
12011 <         test ! -s conftest.err
12012 <       } && test -s conftest$ac_exeext && {
12013 <         test "$cross_compiling" = yes ||
12014 <         $as_test_x conftest$ac_exeext
12015 <       }; then
12016 <  eval "$as_ac_var=yes"
12017 < else
12018 <  $as_echo "$as_me: failed program was:" >&5
12019 < sed 's/^/| /' conftest.$ac_ext >&5
12020 <
12021 <        eval "$as_ac_var=no"
12022 < fi
12023 <
12024 < rm -rf conftest.dSYM
12025 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12026 <      conftest$ac_exeext conftest.$ac_ext
12027 < fi
12028 < ac_res=`eval 'as_val=${'$as_ac_var'}
12029 <                 $as_echo "$as_val"'`
12030 <               { $as_echo "$as_me:$LINENO: result: $ac_res" >&5
12031 < $as_echo "$ac_res" >&6; }
12032 < if test `eval 'as_val=${'$as_ac_var'}
12033 <                 $as_echo "$as_val"'` = yes; then
6384 > for ac_func in atexit floor pow select sqrt strcasecmp strchr strdup strncasecmp strstr strtol strtoull
6385 > do :
6386 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
6387 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
6388 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
6389    cat >>confdefs.h <<_ACEOF
6390   #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
6391   _ACEOF
# Line 12039 | Line 6394 | done
6394   done
6395  
6396  
12042 – # special check for _system_configuration because AIX <4.3.2 do not
12043 – # contain the `physmem' member.
12044 – { $as_echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
12045 – $as_echo_n "checking for external symbol _system_configuration... " >&6; }
12046 – cat >conftest.$ac_ext <<_ACEOF
12047 – /* confdefs.h.  */
12048 – _ACEOF
12049 – cat confdefs.h >>conftest.$ac_ext
12050 – cat >>conftest.$ac_ext <<_ACEOF
12051 – /* end confdefs.h.  */
12052 – #include <sys/systemcfg.h>
12053 – #ifdef FC_DUMMY_MAIN
12054 – #ifndef FC_DUMMY_MAIN_EQ_F77
12055 – #  ifdef __cplusplus
12056 –     extern "C"
12057 – #  endif
12058 –   int FC_DUMMY_MAIN() { return 1; }
12059 – #endif
12060 – #endif
12061 – int
12062 – main ()
12063 – {
12064 – double x = _system_configuration.physmem;
12065 –  ;
12066 –  return 0;
12067 – }
12068 – _ACEOF
12069 – rm -f conftest.$ac_objext
12070 – if { (ac_try="$ac_compile"
12071 – case "(($ac_try" in
12072 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12073 –  *) ac_try_echo=$ac_try;;
12074 – esac
12075 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12076 – $as_echo "$ac_try_echo") >&5
12077 –  (eval "$ac_compile") 2>conftest.er1
12078 –  ac_status=$?
12079 –  grep -v '^ *+' conftest.er1 >conftest.err
12080 –  rm -f conftest.er1
12081 –  cat conftest.err >&5
12082 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12083 –  (exit $ac_status); } && {
12084 –         test -z "$ac_c_werror_flag" ||
12085 –         test ! -s conftest.err
12086 –       } && test -s conftest.$ac_objext; then
12087 –  { $as_echo "$as_me:$LINENO: result: yes" >&5
12088 – $as_echo "yes" >&6; }
6397  
12090 – cat >>confdefs.h <<\_ACEOF
12091 – #define HAVE__SYSTEM_CONFIGURATION 1
12092 – _ACEOF
12093 –
12094 – else
12095 –  $as_echo "$as_me: failed program was:" >&5
12096 – sed 's/^/| /' conftest.$ac_ext >&5
12097 –
12098 –        { $as_echo "$as_me:$LINENO: result: no" >&5
12099 – $as_echo "no" >&6; }
12100 – fi
12101 –
12102 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12103 –
12104 –
6398   case $debug in
6399    1)
6400       ;;
6401    *)
12109 –
12110 –
12111 –
6402  
6403  
12114 – # Try to determine "good" native compiler flags if none specified on command
12115 – # line
6404  
12117 – if test "$ac_test_FFLAGS" != "set"; then
12118 –  FCFLAGS=""
12119 –  case "${host_cpu}-${host_os}" in
6405  
12121 –  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
12122 –                    FCFLAGS="-O2"
12123 –                fi;;
12124 –   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
12125 –                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12126 –                fi;;
12127 –   powerpc*-aix*)
12128 –        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12129 –                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
12130 –                echo "*******************************************************"
12131 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12132 –                echo "*  recommended that you use                           *"
12133 –                echo "*                                                     *"
12134 –                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12135 –                echo "*                                 ^^^                 *"
12136 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12137 –                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
12138 –                echo "*******************************************************"
12139 –        fi;;
12140 –   *darwin*)
12141 –        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
12142 –                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
12143 –        fi
12144 –        if test "$FC" = ifort; then
12145 –                FCFLAGS="-O2"
12146 –        fi
12147 –        if test "$FC" = gfortran; then
12148 –                FCFLAGS="-Os"
12149 –        fi;;
12150 –  esac
6406  
12152 –  if test -z "$FCFLAGS"; then
12153 –        echo ""
12154 –        echo "*********************************************************"
12155 –        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
12156 –        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12157 –        echo "* (otherwise, a default of FCFLAGS=-O will be used)     *"
12158 –        echo "*********************************************************"
12159 –        echo ""
12160 –        FCFLAGS="-O"
12161 –  fi
6407  
6408 <
12164 < { $as_echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
12165 < $as_echo_n "checking whether ${FC} accepts ${FCFLAGS}... " >&6; }
12166 < if test "${ac_guessed_f90flags+set}" = set; then
12167 <  $as_echo_n "(cached) " >&6
12168 < else
12169 <
12170 <
12171 < ac_ext=${ac_fc_srcext-f}
12172 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
12173 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
12174 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
12175 <
12176 < echo 'program main' > conftest.$ac_ext
12177 < echo 'end program main' >> conftest.$ac_ext
12178 < ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
12179 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12180 <  (eval $ac_compile) 2>&5
12181 <  ac_status=$?
12182 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12183 <  (exit $ac_status); }; then
12184 <        ac_guessed_f90flags=yes
12185 < else
12186 <        ac_guessed_f90flags=no
12187 < fi
12188 < rm -f conftest*
12189 < ac_ext=c
12190 < ac_cpp='$CPP $CPPFLAGS'
12191 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
12192 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
12193 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
12194 <
12195 <
12196 < fi
12197 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
12198 < $as_echo "$ac_guessed_f90flags" >&6; }
12199 < if test "$ac_guessed_f90flags" = yes; then
12200 <        :
12201 <
12202 < else
12203 <        :
12204 <
12205 <        echo ""
12206 <        echo "**********************************************************"
12207 <        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
12208 <        echo "* your compiler.                                        *"
12209 <        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
12210 <        echo "*********************************************************"
12211 <        echo ""
12212 <        FCFLAGS=""
12213 <
12214 < fi
12215 <
12216 <
12217 < fi
12218 <
12219 <
12220 <
12221 <
12222 <
12223 <
12224 <
12225 < { $as_echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
6408 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU cc" >&5
6409   $as_echo_n "checking whether we are *really* using GNU cc... " >&6; }
6410 < if test "${ac_cv_prog_really_gcc+set}" = set; then
6410 > if ${ac_cv_prog_really_gcc+:} false; then :
6411    $as_echo_n "(cached) " >&6
6412   else
6413  
# Line 12238 | Line 6421 | if { ac_try='${CC-cc} -E conftest.c'
6421   #endif
6422   EOF
6423   if { ac_try='${CC-cc} -E conftest.c'
6424 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6424 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
6425    (eval $ac_try) 2>&5
6426    ac_status=$?
6427 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
6428 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
6427 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6428 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
6429    ac_cv_prog_really_gcc=yes
6430   else
6431    ac_cv_prog_really_gcc=no
6432   fi
6433  
6434   fi
6435 < { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
6435 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gcc" >&5
6436   $as_echo "$ac_cv_prog_really_gcc" >&6; }
6437   if test "$ac_cv_prog_really_gcc" = yes; then
6438          :
# Line 12327 | Line 6510 | if test "$ac_test_CFLAGS" != "set"; then
6510  
6511  
6512  
6513 < { $as_echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
6513 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts ${CFLAGS}" >&5
6514   $as_echo_n "checking whether ${CC} accepts ${CFLAGS}... " >&6; }
6515 < if test "${ac_guessed_cflags+set}" = set; then
6515 > if ${ac_cv_ac_cv_guessed_cflags+:} false; then :
6516    $as_echo_n "(cached) " >&6
6517   else
6518    echo 'void f(){}' > conftest.c
6519   if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
6520 <        ac_guessed_cflags=yes
6520 >        ac_cv_ac_cv_guessed_cflags=yes
6521   else
6522 <        ac_guessed_cflags=no
6522 >        ac_cv_ac_cv_guessed_cflags=no
6523   fi
6524   rm -f conftest*
6525  
6526   fi
6527 < { $as_echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
6528 < $as_echo "$ac_guessed_cflags" >&6; }
6529 < if test "$ac_guessed_cflags" = yes; then
6527 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cflags" >&5
6528 > $as_echo "$ac_cv_ac_cv_guessed_cflags" >&6; }
6529 > if test "$ac_cv_ac_cv_guessed_cflags" = yes; then
6530          :
6531  
6532   else
# Line 12359 | Line 6542 | fi
6542          CFLAGS=""
6543  
6544   fi
12362 –
12363 –
12364 – fi
12365 –
12366 –
12367 –
12368 –
12369 –
12370 –
12371 –
12372 – { $as_echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
12373 – $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
12374 – if test "${ac_cv_prog_really_gxx+set}" = set; then
12375 –  $as_echo_n "(cached) " >&6
12376 – else
12377 –
12378 – cat > conftest.cpp <<EOF
12379 – #ifdef __GNUC__
12380 –  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12381 –     no;
12382 –  #else
12383 –     yes;
12384 –  #endif
12385 – #endif
12386 – EOF
12387 – if { ac_try='${CXX-c++} -E conftest.cpp'
12388 –  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12389 –  (eval $ac_try) 2>&5
12390 –  ac_status=$?
12391 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12392 –  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12393 –  ac_cv_prog_really_gxx=yes
12394 – else
12395 –  ac_cv_prog_really_gxx=no
12396 – fi
12397 –
12398 – fi
12399 – { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
12400 – $as_echo "$ac_cv_prog_really_gxx" >&6; }
12401 – if test "$ac_cv_prog_really_gxx" = yes; then
12402 –        :
12403 –
12404 – else
12405 –        :
12406 –
12407 – fi
12408 –
12409 –
12410 – # Try to determine "good" native compiler flags if none specified on command
12411 – # line
12412 – if test "$ac_test_CXXFLAGS" != "set"; then
12413 –  CXXFLAGS=""
12414 –  case "${host_cpu}-${host_os}" in
12415 –
12416 –  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
12417 –                    CXXFLAGS="-O2"
12418 –                fi;;
12419 –  sparc-solaris2*) if test "$CXX" = CC; then
12420 –                    CXXFLAGS="-features=extensions -O -dalign"
12421 –                 fi;;
12422 –   rs6000*-aix*)  if test "$CXX" = xlC; then
12423 –                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12424 –                fi;;
12425 –   powerpc*-aix*)
12426 –        if test "$CXX" = xlC; then
12427 –                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
12428 –                echo "*******************************************************"
12429 –                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12430 –                echo "*  recommended that you use                           *"
12431 –                echo "*                                                     *"
12432 –                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12433 –                echo "*                                 ^^^                 *"
12434 –                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12435 –                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12436 –                echo "*******************************************************"
12437 –        fi;;
12438 –   *darwin*)
12439 –        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12440 –                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12441 –        fi
12442 –        if test "$CXX" = icpc; then
12443 –                CXXFLAGS="-O2"
12444 –        fi
12445 –        if test $ac_cv_prog_really_gxx = yes; then
12446 –                CXXFLAGS="-Os"
12447 –        fi;;
12448 –  esac
12449 –
12450 –  # use default flags for gcc on all systems
12451 –  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
12452 –     CXXFLAGS="-O2"
12453 –  fi
12454 –
12455 –  if test -z "$CXXFLAGS"; then
12456 –        echo ""
12457 –        echo "**********************************************************"
12458 –        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12459 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12460 –        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
12461 –        echo "**********************************************************"
12462 –        echo ""
12463 –        CXXFLAGS="-O"
12464 –  fi
12465 –
12466 –
12467 –
12468 – { $as_echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12469 – $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
12470 – if test "${ac_guessed_cxxflags+set}" = set; then
12471 –  $as_echo_n "(cached) " >&6
12472 – else
12473 –  echo 'void f(){}' > conftest.cpp
12474 – if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12475 –        ac_guessed_cxxflags=yes
12476 – else
12477 –        ac_guessed_cxxflags=no
12478 – fi
12479 – rm -f conftest*
12480 –
12481 – fi
12482 – { $as_echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12483 – $as_echo "$ac_guessed_cxxflags" >&6; }
12484 – if test "$ac_guessed_cxxflags" = yes; then
12485 –        :
12486 –
12487 – else
12488 –        :
12489 –
12490 –        echo ""
12491 –        echo "**********************************************************"
12492 –        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12493 –        echo "* your compiler.                                         *"
12494 –        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12495 –        echo "**********************************************************"
12496 –        echo ""
12497 –        CXXFLAGS=""
12498 –
12499 – fi
12500 –
12501 –
12502 – fi
12503 –
12504 –     ;;
12505 – esac
12506 –
12507 –
12508 – acx_cgal_found=no
12509 –
12510 – # Check whether --with-cgalmakefile was given.
12511 – if test "${with_cgalmakefile+set}" = set; then
12512 –  withval=$with_cgalmakefile;
12513 – fi
12514 –
12515 – case $with_cgalmakefile in
12516 –        yes | "") ;;
12517 –        no) acx_cgal_found=disable ;;
12518 –        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
12519 –        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
12520 – esac
12521 –
12522 – if test "$acx_cgal_found" == no; then
12523 –    { $as_echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
12524 – $as_echo_n "checking CGAL_MAKEFILE... " >&6; }
12525 –
12526 –    if test \! -z "$CGAL_MAKEFILE"; then
12527 –
12528 –        if test -e "$CGAL_MAKEFILE"; then
12529 –            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
12530 –
12531 – cat > $tname << _ACEOF
12532 – include $CGAL_MAKEFILE
12533 –
12534 – cppflags:
12535 –        @echo \$(CGAL_CXXFLAGS)
12536 –
12537 – cxxflags:
12538 –        @echo
12539 – ldflags:
12540 –        @echo \$(CGAL_LDFLAGS)
12541 – _ACEOF
12542 –            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
12543 –            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
12544 –            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
12545 –            for i in $CGAL_LDFLAGST; do
12546 –                if test `echo $i| grep -c ^-l`; then
12547 –                    CGAL_LIBS="$CGAL_LIBS $i"
12548 –                else
12549 –                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
12550 –                fi
12551 –            done
12552 –            rm -f $tname
12553 –            { $as_echo "$as_me:$LINENO: result: yes" >&5
12554 – $as_echo "yes" >&6; }
12555 –            acx_cgal_found=yes
12556 –                                   else
12557 –            { $as_echo "$as_me:$LINENO: result: invalid" >&5
12558 – $as_echo "invalid" >&6; }
12559 –            { { $as_echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
12560 – $as_echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
12561 –   { (exit 1); exit 1; }; }
12562 –        fi
12563 –    else
12564 –        { $as_echo "$as_me:$LINENO: result: not defined" >&5
12565 – $as_echo "not defined" >&6; }
12566 –    fi
12567 – fi
12568 –
12569 – if test "$acx_cgal_found" == no; then
12570 –        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12571 –  { $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12572 – $as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12573 – if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12574 –  $as_echo_n "(cached) " >&6
12575 – fi
12576 – { $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12577 – $as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12578 – else
12579 –  # Is the header compilable?
12580 – { $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
12581 – $as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... " >&6; }
12582 – cat >conftest.$ac_ext <<_ACEOF
12583 – /* confdefs.h.  */
12584 – _ACEOF
12585 – cat confdefs.h >>conftest.$ac_ext
12586 – cat >>conftest.$ac_ext <<_ACEOF
12587 – /* end confdefs.h.  */
12588 – $ac_includes_default
12589 – #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12590 – _ACEOF
12591 – rm -f conftest.$ac_objext
12592 – if { (ac_try="$ac_compile"
12593 – case "(($ac_try" in
12594 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12595 –  *) ac_try_echo=$ac_try;;
12596 – esac
12597 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12598 – $as_echo "$ac_try_echo") >&5
12599 –  (eval "$ac_compile") 2>conftest.er1
12600 –  ac_status=$?
12601 –  grep -v '^ *+' conftest.er1 >conftest.err
12602 –  rm -f conftest.er1
12603 –  cat conftest.err >&5
12604 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12605 –  (exit $ac_status); } && {
12606 –         test -z "$ac_c_werror_flag" ||
12607 –         test ! -s conftest.err
12608 –       } && test -s conftest.$ac_objext; then
12609 –  ac_header_compiler=yes
12610 – else
12611 –  $as_echo "$as_me: failed program was:" >&5
12612 – sed 's/^/| /' conftest.$ac_ext >&5
12613 –
12614 –        ac_header_compiler=no
12615 – fi
12616 –
12617 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12618 – { $as_echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12619 – $as_echo "$ac_header_compiler" >&6; }
12620 –
12621 – # Is the header present?
12622 – { $as_echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
12623 – $as_echo_n "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... " >&6; }
12624 – cat >conftest.$ac_ext <<_ACEOF
12625 – /* confdefs.h.  */
12626 – _ACEOF
12627 – cat confdefs.h >>conftest.$ac_ext
12628 – cat >>conftest.$ac_ext <<_ACEOF
12629 – /* end confdefs.h.  */
12630 – #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12631 – _ACEOF
12632 – if { (ac_try="$ac_cpp conftest.$ac_ext"
12633 – case "(($ac_try" in
12634 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12635 –  *) ac_try_echo=$ac_try;;
12636 – esac
12637 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12638 – $as_echo "$ac_try_echo") >&5
12639 –  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
12640 –  ac_status=$?
12641 –  grep -v '^ *+' conftest.er1 >conftest.err
12642 –  rm -f conftest.er1
12643 –  cat conftest.err >&5
12644 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12645 –  (exit $ac_status); } >/dev/null && {
12646 –         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12647 –         test ! -s conftest.err
12648 –       }; then
12649 –  ac_header_preproc=yes
12650 – else
12651 –  $as_echo "$as_me: failed program was:" >&5
12652 – sed 's/^/| /' conftest.$ac_ext >&5
12653 –
12654 –  ac_header_preproc=no
12655 – fi
12656 –
12657 – rm -f conftest.err conftest.$ac_ext
12658 – { $as_echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
12659 – $as_echo "$ac_header_preproc" >&6; }
12660 –
12661 – # So?  What about this header?
12662 – case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12663 –  yes:no: )
12664 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
12665 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
12666 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
12667 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
12668 –    ac_header_preproc=yes
12669 –    ;;
12670 –  no:yes:* )
12671 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
12672 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
12673 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
12674 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
12675 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
12676 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
12677 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
12678 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
12679 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
12680 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
12681 –    { $as_echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
12682 – $as_echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
12683 –    ( cat <<\_ASBOX
12684 – ## ------------------------------ ##
12685 – ## Report this to gezelter@nd.edu ##
12686 – ## ------------------------------ ##
12687 – _ASBOX
12688 –     ) | sed "s/^/$as_me: WARNING:     /" >&2
12689 –    ;;
12690 – esac
12691 – { $as_echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12692 – $as_echo_n "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... " >&6; }
12693 – if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12694 –  $as_echo_n "(cached) " >&6
12695 – else
12696 –  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
12697 – fi
12698 – { $as_echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12699 – $as_echo "$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12700 –
12701 – fi
12702 – if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
12703 –  cgal_have_header=yes
12704 – else
12705 –  cgal_have_header=no
12706 – fi
12707 –
12708 –
12709 –        if test "$cgal_have_header" == yes; then
12710 –                { $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
12711 – $as_echo_n "checking for main in -lCGAL... " >&6; }
12712 – if test "${ac_cv_lib_CGAL_main+set}" = set; then
12713 –  $as_echo_n "(cached) " >&6
12714 – else
12715 –  ac_check_lib_save_LIBS=$LIBS
12716 – LIBS="-lCGAL  $LIBS"
12717 – cat >conftest.$ac_ext <<_ACEOF
12718 – /* confdefs.h.  */
12719 – _ACEOF
12720 – cat confdefs.h >>conftest.$ac_ext
12721 – cat >>conftest.$ac_ext <<_ACEOF
12722 – /* end confdefs.h.  */
12723 –
12724 –
12725 – #ifdef FC_DUMMY_MAIN
12726 – #ifndef FC_DUMMY_MAIN_EQ_F77
12727 – #  ifdef __cplusplus
12728 –     extern "C"
12729 – #  endif
12730 –   int FC_DUMMY_MAIN() { return 1; }
12731 – #endif
12732 – #endif
12733 – int
12734 – main ()
12735 – {
12736 – return main ();
12737 –  ;
12738 –  return 0;
12739 – }
12740 – _ACEOF
12741 – rm -f conftest.$ac_objext conftest$ac_exeext
12742 – if { (ac_try="$ac_link"
12743 – case "(($ac_try" in
12744 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12745 –  *) ac_try_echo=$ac_try;;
12746 – esac
12747 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12748 – $as_echo "$ac_try_echo") >&5
12749 –  (eval "$ac_link") 2>conftest.er1
12750 –  ac_status=$?
12751 –  grep -v '^ *+' conftest.er1 >conftest.err
12752 –  rm -f conftest.er1
12753 –  cat conftest.err >&5
12754 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12755 –  (exit $ac_status); } && {
12756 –         test -z "$ac_c_werror_flag" ||
12757 –         test ! -s conftest.err
12758 –       } && test -s conftest$ac_exeext && {
12759 –         test "$cross_compiling" = yes ||
12760 –         $as_test_x conftest$ac_exeext
12761 –       }; then
12762 –  ac_cv_lib_CGAL_main=yes
12763 – else
12764 –  $as_echo "$as_me: failed program was:" >&5
12765 – sed 's/^/| /' conftest.$ac_ext >&5
12766 –
12767 –        ac_cv_lib_CGAL_main=no
12768 – fi
12769 –
12770 – rm -rf conftest.dSYM
12771 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12772 –      conftest$ac_exeext conftest.$ac_ext
12773 – LIBS=$ac_check_lib_save_LIBS
12774 – fi
12775 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
12776 – $as_echo "$ac_cv_lib_CGAL_main" >&6; }
12777 – if test $ac_cv_lib_CGAL_main = yes; then
12778 –  cgal_have_lib=yes
12779 – else
12780 –  cgal_have_lib=no
12781 – fi
12782 –
12783 –                if test "$cgal_have_lib" == no; then
12784 –                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
12785 –                        { $as_echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
12786 – $as_echo_n "checking for main in -lCGAL... " >&6; }
12787 – if test "${ac_cv_lib_CGAL_main+set}" = set; then
12788 –  $as_echo_n "(cached) " >&6
12789 – else
12790 –  ac_check_lib_save_LIBS=$LIBS
12791 – LIBS="-lCGAL  $LIBS"
12792 – cat >conftest.$ac_ext <<_ACEOF
12793 – /* confdefs.h.  */
12794 – _ACEOF
12795 – cat confdefs.h >>conftest.$ac_ext
12796 – cat >>conftest.$ac_ext <<_ACEOF
12797 – /* end confdefs.h.  */
12798 –
12799 –
12800 – #ifdef FC_DUMMY_MAIN
12801 – #ifndef FC_DUMMY_MAIN_EQ_F77
12802 – #  ifdef __cplusplus
12803 –     extern "C"
12804 – #  endif
12805 –   int FC_DUMMY_MAIN() { return 1; }
12806 – #endif
12807 – #endif
12808 – int
12809 – main ()
12810 – {
12811 – return main ();
12812 –  ;
12813 –  return 0;
12814 – }
12815 – _ACEOF
12816 – rm -f conftest.$ac_objext conftest$ac_exeext
12817 – if { (ac_try="$ac_link"
12818 – case "(($ac_try" in
12819 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12820 –  *) ac_try_echo=$ac_try;;
12821 – esac
12822 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12823 – $as_echo "$ac_try_echo") >&5
12824 –  (eval "$ac_link") 2>conftest.er1
12825 –  ac_status=$?
12826 –  grep -v '^ *+' conftest.er1 >conftest.err
12827 –  rm -f conftest.er1
12828 –  cat conftest.err >&5
12829 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12830 –  (exit $ac_status); } && {
12831 –         test -z "$ac_c_werror_flag" ||
12832 –         test ! -s conftest.err
12833 –       } && test -s conftest$ac_exeext && {
12834 –         test "$cross_compiling" = yes ||
12835 –         $as_test_x conftest$ac_exeext
12836 –       }; then
12837 –  ac_cv_lib_CGAL_main=yes
12838 – else
12839 –  $as_echo "$as_me: failed program was:" >&5
12840 – sed 's/^/| /' conftest.$ac_ext >&5
12841 –
12842 –        ac_cv_lib_CGAL_main=no
12843 – fi
12844 –
12845 – rm -rf conftest.dSYM
12846 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12847 –      conftest$ac_exeext conftest.$ac_ext
12848 – LIBS=$ac_check_lib_save_LIBS
12849 – fi
12850 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
12851 – $as_echo "$ac_cv_lib_CGAL_main" >&6; }
12852 – if test $ac_cv_lib_CGAL_main = yes; then
12853 –  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
12854 –                                                  cgal_have_lib=yes
12855 – else
12856 –  cgal_have_lib=no
12857 – fi
12858 –
12859 –                        LIBS="$save_LIBS"
12860 –                else
12861 –                        CGAL_LIBS="-lCGAL"
12862 –                        { $as_echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
12863 – $as_echo_n "checking for main in -lmpfr... " >&6; }
12864 – if test "${ac_cv_lib_mpfr_main+set}" = set; then
12865 –  $as_echo_n "(cached) " >&6
12866 – else
12867 –  ac_check_lib_save_LIBS=$LIBS
12868 – LIBS="-lmpfr  $LIBS"
12869 – cat >conftest.$ac_ext <<_ACEOF
12870 – /* confdefs.h.  */
12871 – _ACEOF
12872 – cat confdefs.h >>conftest.$ac_ext
12873 – cat >>conftest.$ac_ext <<_ACEOF
12874 – /* end confdefs.h.  */
12875 –
12876 –
12877 – #ifdef FC_DUMMY_MAIN
12878 – #ifndef FC_DUMMY_MAIN_EQ_F77
12879 – #  ifdef __cplusplus
12880 –     extern "C"
12881 – #  endif
12882 –   int FC_DUMMY_MAIN() { return 1; }
12883 – #endif
12884 – #endif
12885 – int
12886 – main ()
12887 – {
12888 – return main ();
12889 –  ;
12890 –  return 0;
12891 – }
12892 – _ACEOF
12893 – rm -f conftest.$ac_objext conftest$ac_exeext
12894 – if { (ac_try="$ac_link"
12895 – case "(($ac_try" in
12896 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12897 –  *) ac_try_echo=$ac_try;;
12898 – esac
12899 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12900 – $as_echo "$ac_try_echo") >&5
12901 –  (eval "$ac_link") 2>conftest.er1
12902 –  ac_status=$?
12903 –  grep -v '^ *+' conftest.er1 >conftest.err
12904 –  rm -f conftest.er1
12905 –  cat conftest.err >&5
12906 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12907 –  (exit $ac_status); } && {
12908 –         test -z "$ac_c_werror_flag" ||
12909 –         test ! -s conftest.err
12910 –       } && test -s conftest$ac_exeext && {
12911 –         test "$cross_compiling" = yes ||
12912 –         $as_test_x conftest$ac_exeext
12913 –       }; then
12914 –  ac_cv_lib_mpfr_main=yes
12915 – else
12916 –  $as_echo "$as_me: failed program was:" >&5
12917 – sed 's/^/| /' conftest.$ac_ext >&5
12918 –
12919 –        ac_cv_lib_mpfr_main=no
12920 – fi
12921 –
12922 – rm -rf conftest.dSYM
12923 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12924 –      conftest$ac_exeext conftest.$ac_ext
12925 – LIBS=$ac_check_lib_save_LIBS
12926 – fi
12927 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
12928 – $as_echo "$ac_cv_lib_mpfr_main" >&6; }
12929 – if test $ac_cv_lib_mpfr_main = yes; then
12930 –  CGAL_LIBS="$CGAL_LIBS -lmpfr"
12931 – fi
12932 –
12933 –                        { $as_echo "$as_me:$LINENO: checking for main in -lgmp" >&5
12934 – $as_echo_n "checking for main in -lgmp... " >&6; }
12935 – if test "${ac_cv_lib_gmp_main+set}" = set; then
12936 –  $as_echo_n "(cached) " >&6
12937 – else
12938 –  ac_check_lib_save_LIBS=$LIBS
12939 – LIBS="-lgmp  $LIBS"
12940 – cat >conftest.$ac_ext <<_ACEOF
12941 – /* confdefs.h.  */
12942 – _ACEOF
12943 – cat confdefs.h >>conftest.$ac_ext
12944 – cat >>conftest.$ac_ext <<_ACEOF
12945 – /* end confdefs.h.  */
12946 –
12947 –
12948 – #ifdef FC_DUMMY_MAIN
12949 – #ifndef FC_DUMMY_MAIN_EQ_F77
12950 – #  ifdef __cplusplus
12951 –     extern "C"
12952 – #  endif
12953 –   int FC_DUMMY_MAIN() { return 1; }
12954 – #endif
12955 – #endif
12956 – int
12957 – main ()
12958 – {
12959 – return main ();
12960 –  ;
12961 –  return 0;
12962 – }
12963 – _ACEOF
12964 – rm -f conftest.$ac_objext conftest$ac_exeext
12965 – if { (ac_try="$ac_link"
12966 – case "(($ac_try" in
12967 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12968 –  *) ac_try_echo=$ac_try;;
12969 – esac
12970 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
12971 – $as_echo "$ac_try_echo") >&5
12972 –  (eval "$ac_link") 2>conftest.er1
12973 –  ac_status=$?
12974 –  grep -v '^ *+' conftest.er1 >conftest.err
12975 –  rm -f conftest.er1
12976 –  cat conftest.err >&5
12977 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
12978 –  (exit $ac_status); } && {
12979 –         test -z "$ac_c_werror_flag" ||
12980 –         test ! -s conftest.err
12981 –       } && test -s conftest$ac_exeext && {
12982 –         test "$cross_compiling" = yes ||
12983 –         $as_test_x conftest$ac_exeext
12984 –       }; then
12985 –  ac_cv_lib_gmp_main=yes
12986 – else
12987 –  $as_echo "$as_me: failed program was:" >&5
12988 – sed 's/^/| /' conftest.$ac_ext >&5
6545  
12990 –        ac_cv_lib_gmp_main=no
12991 – fi
6546  
12993 – rm -rf conftest.dSYM
12994 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12995 –      conftest$ac_exeext conftest.$ac_ext
12996 – LIBS=$ac_check_lib_save_LIBS
6547   fi
12998 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
12999 – $as_echo "$ac_cv_lib_gmp_main" >&6; }
13000 – if test $ac_cv_lib_gmp_main = yes; then
13001 –  CGAL_LIBS="$CGAL_LIBS -lgmp"
13002 – fi
6548  
13004 –                        { $as_echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
13005 – $as_echo_n "checking for main in -lgmpxx... " >&6; }
13006 – if test "${ac_cv_lib_gmpxx_main+set}" = set; then
13007 –  $as_echo_n "(cached) " >&6
13008 – else
13009 –  ac_check_lib_save_LIBS=$LIBS
13010 – LIBS="-lgmpxx  $LIBS"
13011 – cat >conftest.$ac_ext <<_ACEOF
13012 – /* confdefs.h.  */
13013 – _ACEOF
13014 – cat confdefs.h >>conftest.$ac_ext
13015 – cat >>conftest.$ac_ext <<_ACEOF
13016 – /* end confdefs.h.  */
6549  
6550  
13019 – #ifdef FC_DUMMY_MAIN
13020 – #ifndef FC_DUMMY_MAIN_EQ_F77
13021 – #  ifdef __cplusplus
13022 –     extern "C"
13023 – #  endif
13024 –   int FC_DUMMY_MAIN() { return 1; }
13025 – #endif
13026 – #endif
13027 – int
13028 – main ()
13029 – {
13030 – return main ();
13031 –  ;
13032 –  return 0;
13033 – }
13034 – _ACEOF
13035 – rm -f conftest.$ac_objext conftest$ac_exeext
13036 – if { (ac_try="$ac_link"
13037 – case "(($ac_try" in
13038 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13039 –  *) ac_try_echo=$ac_try;;
13040 – esac
13041 – eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13042 – $as_echo "$ac_try_echo") >&5
13043 –  (eval "$ac_link") 2>conftest.er1
13044 –  ac_status=$?
13045 –  grep -v '^ *+' conftest.er1 >conftest.err
13046 –  rm -f conftest.er1
13047 –  cat conftest.err >&5
13048 –  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13049 –  (exit $ac_status); } && {
13050 –         test -z "$ac_c_werror_flag" ||
13051 –         test ! -s conftest.err
13052 –       } && test -s conftest$ac_exeext && {
13053 –         test "$cross_compiling" = yes ||
13054 –         $as_test_x conftest$ac_exeext
13055 –       }; then
13056 –  ac_cv_lib_gmpxx_main=yes
13057 – else
13058 –  $as_echo "$as_me: failed program was:" >&5
13059 – sed 's/^/| /' conftest.$ac_ext >&5
6551  
13061 –        ac_cv_lib_gmpxx_main=no
13062 – fi
6552  
13064 – rm -rf conftest.dSYM
13065 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13066 –      conftest$ac_exeext conftest.$ac_ext
13067 – LIBS=$ac_check_lib_save_LIBS
13068 – fi
13069 – { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
13070 – $as_echo "$ac_cv_lib_gmpxx_main" >&6; }
13071 – if test $ac_cv_lib_gmpxx_main = yes; then
13072 –  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
13073 – fi
6553  
13075 –                fi
6554  
6555 <                if test "$cgal_have_lib" == yes; then
6556 <                        acx_cgal_found=yes
6557 <                fi
13080 <        fi
13081 <        if test "$acx_cgal_found" == yes; then
13082 <                { $as_echo "$as_me:$LINENO: checking for main in -lCore" >&5
13083 < $as_echo_n "checking for main in -lCore... " >&6; }
13084 < if test "${ac_cv_lib_Core_main+set}" = set; then
6555 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU c++" >&5
6556 > $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
6557 > if ${ac_cv_prog_really_gxx+:} false; then :
6558    $as_echo_n "(cached) " >&6
6559   else
13087 –  ac_check_lib_save_LIBS=$LIBS
13088 – LIBS="-lCore  $LIBS"
13089 – cat >conftest.$ac_ext <<_ACEOF
13090 – /* confdefs.h.  */
13091 – _ACEOF
13092 – cat confdefs.h >>conftest.$ac_ext
13093 – cat >>conftest.$ac_ext <<_ACEOF
13094 – /* end confdefs.h.  */
6560  
6561 <
6562 < #ifdef FC_DUMMY_MAIN
6563 < #ifndef FC_DUMMY_MAIN_EQ_F77
6564 < #  ifdef __cplusplus
6565 <     extern "C"
6566 < #  endif
6567 <   int FC_DUMMY_MAIN() { return 1; }
6561 > cat > conftest.cpp <<EOF
6562 > #ifdef __GNUC__
6563 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
6564 >     no;
6565 >  #else
6566 >     yes;
6567 >  #endif
6568   #endif
6569 < #endif
6570 < int
6571 < main ()
6572 < {
13108 < return main ();
13109 <  ;
13110 <  return 0;
13111 < }
13112 < _ACEOF
13113 < rm -f conftest.$ac_objext conftest$ac_exeext
13114 < if { (ac_try="$ac_link"
13115 < case "(($ac_try" in
13116 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
13117 <  *) ac_try_echo=$ac_try;;
13118 < esac
13119 < eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
13120 < $as_echo "$ac_try_echo") >&5
13121 <  (eval "$ac_link") 2>conftest.er1
6569 > EOF
6570 > if { ac_try='${CXX-c++} -E conftest.cpp'
6571 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
6572 >  (eval $ac_try) 2>&5
6573    ac_status=$?
6574 <  grep -v '^ *+' conftest.er1 >conftest.err
6575 <  rm -f conftest.er1
6576 <  cat conftest.err >&5
13126 <  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
13127 <  (exit $ac_status); } && {
13128 <         test -z "$ac_c_werror_flag" ||
13129 <         test ! -s conftest.err
13130 <       } && test -s conftest$ac_exeext && {
13131 <         test "$cross_compiling" = yes ||
13132 <         $as_test_x conftest$ac_exeext
13133 <       }; then
13134 <  ac_cv_lib_Core_main=yes
6574 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6575 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
6576 >  ac_cv_prog_really_gxx=yes
6577   else
6578 <  $as_echo "$as_me: failed program was:" >&5
13137 < sed 's/^/| /' conftest.$ac_ext >&5
13138 <
13139 <        ac_cv_lib_Core_main=no
6578 >  ac_cv_prog_really_gxx=no
6579   fi
6580  
13142 – rm -rf conftest.dSYM
13143 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
13144 –      conftest$ac_exeext conftest.$ac_ext
13145 – LIBS=$ac_check_lib_save_LIBS
6581   fi
6582 < { $as_echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
6583 < $as_echo "$ac_cv_lib_Core_main" >&6; }
6584 < if test $ac_cv_lib_Core_main = yes; then
6585 <  CGAL_LIBS="$CGAL_LIBS -lCore"
13151 < fi
6582 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gxx" >&5
6583 > $as_echo "$ac_cv_prog_really_gxx" >&6; }
6584 > if test "$ac_cv_prog_really_gxx" = yes; then
6585 >        :
6586  
6587 <        fi
6587 > else
6588 >        :
6589 >
6590   fi
6591  
6592  
6593 + # Try to determine "good" native compiler flags if none specified on command
6594 + # line
6595 + if test "$ac_test_CXXFLAGS" != "set"; then
6596 +  CXXFLAGS=""
6597 +  case "${host_cpu}-${host_os}" in
6598  
6599 < { $as_echo "$as_me:$LINENO: checking CGAL" >&5
6600 < $as_echo_n "checking CGAL... " >&6; }
6599 >  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
6600 >                    CXXFLAGS="-O2"
6601 >                fi;;
6602 >  sparc-solaris2*) if test "$CXX" = CC; then
6603 >                    CXXFLAGS="-features=extensions -O -dalign"
6604 >                 fi;;
6605 >   rs6000*-aix*)  if test "$CXX" = xlC; then
6606 >                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
6607 >                fi;;
6608 >   powerpc*-aix*)
6609 >        if test "$CXX" = xlC; then
6610 >                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
6611 >                echo "*******************************************************"
6612 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6613 >                echo "*  recommended that you use                           *"
6614 >                echo "*                                                     *"
6615 >                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6616 >                echo "*                                 ^^^                 *"
6617 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6618 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
6619 >                echo "*******************************************************"
6620 >        fi;;
6621 >   *darwin*)
6622 >        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
6623 >                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
6624 >        fi
6625 >        if test "$CXX" = icpc; then
6626 >                CXXFLAGS="-O2"
6627 >        fi
6628 >        if test $ac_cv_prog_really_gxx = yes; then
6629 >                CXXFLAGS="-Os"
6630 >        fi;;
6631 >  esac
6632  
6633 +  # use default flags for gcc on all systems
6634 +  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
6635 +     CXXFLAGS="-O2"
6636 +  fi
6637  
6638 +  if test -z "$CXXFLAGS"; then
6639 +        echo ""
6640 +        echo "**********************************************************"
6641 +        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
6642 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6643 +        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
6644 +        echo "**********************************************************"
6645 +        echo ""
6646 +        CXXFLAGS="-O"
6647 +  fi
6648  
6649  
6650  
6651 < if test "$acx_cgal_found" == yes; then
6652 <        { $as_echo "$as_me:$LINENO: result: yes" >&5
6653 < $as_echo "yes" >&6; }
6654 <
6651 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
6652 > $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
6653 > if ${ac_cv_ac_cv_guessed_cxxflags+:} false; then :
6654 >  $as_echo_n "(cached) " >&6
6655   else
6656 <        { $as_echo "$as_me:$LINENO: result: no" >&5
6657 < $as_echo "no" >&6; }
6658 <
6656 >  echo 'void f(){}' > conftest.cpp
6657 > if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
6658 >        ac_cv_ac_cv_guessed_cxxflags=yes
6659 > else
6660 >        ac_cv_ac_cv_guessed_cxxflags=no
6661   fi
6662 < USE_CGAL=no
13175 < if test "$acx_cgal_found" == yes; then
13176 <        USE_CGAL=yes
6662 > rm -f conftest*
6663  
6664 < cat >>confdefs.h <<\_ACEOF
6665 < #define HAVE_CGAL 1
6666 < _ACEOF
6664 > fi
6665 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cxxflags" >&5
6666 > $as_echo "$ac_cv_ac_cv_guessed_cxxflags" >&6; }
6667 > if test "$ac_cv_ac_cv_guessed_cxxflags" = yes; then
6668 >        :
6669  
6670 + else
6671 +        :
6672  
6673 +        echo ""
6674 +        echo "**********************************************************"
6675 +        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
6676 +        echo "* your compiler.                                         *"
6677 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
6678 +        echo "**********************************************************"
6679 +        echo ""
6680 +        CXXFLAGS=""
6681  
6682 + fi
6683  
6684  
6685   fi
6686  
6687 +     ;;
6688 + esac
6689  
6690  
13190 –
6691   # Check whether --enable-doxygen was given.
6692 < if test "${enable_doxygen+set}" = set; then
6692 > if test "${enable_doxygen+set}" = set; then :
6693    enableval=$enable_doxygen;
6694   fi
6695  
6696   # Check whether --enable-dot was given.
6697 < if test "${enable_dot+set}" = set; then
6697 > if test "${enable_dot+set}" = set; then :
6698    enableval=$enable_dot;
6699   fi
6700  
6701   # Check whether --enable-html-docs was given.
6702 < if test "${enable_html_docs+set}" = set; then
6702 > if test "${enable_html_docs+set}" = set; then :
6703    enableval=$enable_html_docs;
6704   else
6705     enable_html_docs=yes
6706   fi
6707  
6708   # Check whether --enable-latex-docs was given.
6709 < if test "${enable_latex_docs+set}" = set; then
6709 > if test "${enable_latex_docs+set}" = set; then :
6710    enableval=$enable_latex_docs;
6711   else
6712     enable_latex_docs=no
# Line 13217 | Line 6717 | set dummy doxygen; ac_word=$2
6717   else
6718          # Extract the first word of "doxygen", so it can be a program name with args.
6719   set dummy doxygen; ac_word=$2
6720 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6720 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6721   $as_echo_n "checking for $ac_word... " >&6; }
6722 < if test "${ac_cv_path_DOXYGEN+set}" = set; then
6722 > if ${ac_cv_path_DOXYGEN+:} false; then :
6723    $as_echo_n "(cached) " >&6
6724   else
6725    case $DOXYGEN in
# Line 13232 | Line 6732 | do
6732   do
6733    IFS=$as_save_IFS
6734    test -z "$as_dir" && as_dir=.
6735 <  for ac_exec_ext in '' $ac_executable_extensions; do
6735 >    for ac_exec_ext in '' $ac_executable_extensions; do
6736    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6737      ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
6738 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6738 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6739      break 2
6740    fi
6741   done
6742 < done
6742 >  done
6743   IFS=$as_save_IFS
6744  
6745    ;;
# Line 13247 | Line 6747 | if test -n "$DOXYGEN"; then
6747   fi
6748   DOXYGEN=$ac_cv_path_DOXYGEN
6749   if test -n "$DOXYGEN"; then
6750 <  { $as_echo "$as_me:$LINENO: result: $DOXYGEN" >&5
6750 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOXYGEN" >&5
6751   $as_echo "$DOXYGEN" >&6; }
6752   else
6753 <  { $as_echo "$as_me:$LINENO: result: no" >&5
6753 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6754   $as_echo "no" >&6; }
6755   fi
6756  
6757  
6758          if test "x$DOXYGEN" = x; then
6759                  if test "x$enable_doxygen" = xyes; then
6760 <                        { { $as_echo "$as_me:$LINENO: error: could not find doxygen" >&5
13261 < $as_echo "$as_me: error: could not find doxygen" >&2;}
13262 <   { (exit 1); exit 1; }; }
6760 >                        as_fn_error $? "could not find doxygen" "$LINENO" 5
6761                  fi
6762                  enable_doc=no
6763          else
6764                  enable_doc=yes
6765                  # Extract the first word of "dot", so it can be a program name with args.
6766   set dummy dot; ac_word=$2
6767 < { $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
6767 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
6768   $as_echo_n "checking for $ac_word... " >&6; }
6769 < if test "${ac_cv_path_DOT+set}" = set; then
6769 > if ${ac_cv_path_DOT+:} false; then :
6770    $as_echo_n "(cached) " >&6
6771   else
6772    case $DOT in
# Line 13281 | Line 6779 | do
6779   do
6780    IFS=$as_save_IFS
6781    test -z "$as_dir" && as_dir=.
6782 <  for ac_exec_ext in '' $ac_executable_extensions; do
6782 >    for ac_exec_ext in '' $ac_executable_extensions; do
6783    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6784      ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
6785 <    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6785 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
6786      break 2
6787    fi
6788   done
6789 < done
6789 >  done
6790   IFS=$as_save_IFS
6791  
6792    ;;
# Line 13296 | Line 6794 | if test -n "$DOT"; then
6794   fi
6795   DOT=$ac_cv_path_DOT
6796   if test -n "$DOT"; then
6797 <  { $as_echo "$as_me:$LINENO: result: $DOT" >&5
6797 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
6798   $as_echo "$DOT" >&6; }
6799   else
6800 <  { $as_echo "$as_me:$LINENO: result: no" >&5
6800 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6801   $as_echo "no" >&6; }
6802   fi
6803  
# Line 13316 | Line 6814 | if test x$DOT = x; then
6814  
6815   if test x$DOT = x; then
6816          if test "x$enable_dot" = xyes; then
6817 <                { { $as_echo "$as_me:$LINENO: error: could not find dot" >&5
13320 < $as_echo "$as_me: error: could not find dot" >&2;}
13321 <   { (exit 1); exit 1; }; }
6817 >                as_fn_error $? "could not find dot" "$LINENO" 5
6818          fi
6819          enable_dot=no
6820   else
6821          enable_dot=yes
6822   fi
13327 –
13328 –
13329 –
6823  
6824  
6825  
# Line 13373 | Line 6866 | _ACEOF
6866      case $ac_val in #(
6867      *${as_nl}*)
6868        case $ac_var in #(
6869 <      *_cv_*) { $as_echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
6870 < $as_echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
6869 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
6870 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
6871        esac
6872        case $ac_var in #(
6873        _ | IFS | as_nl) ;; #(
6874        BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
6875 <      *) $as_unset $ac_var ;;
6875 >      *) { eval $ac_var=; unset $ac_var;} ;;
6876        esac ;;
6877      esac
6878    done
# Line 13387 | Line 6880 | $as_echo "$as_me: WARNING: Cache variable $ac_var cont
6880    (set) 2>&1 |
6881      case $as_nl`(ac_space=' '; set) 2>&1` in #(
6882      *${as_nl}ac_space=\ *)
6883 <      # `set' does not quote correctly, so add quotes (double-quote
6884 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
6883 >      # `set' does not quote correctly, so add quotes: double-quote
6884 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
6885        sed -n \
6886          "s/'/'\\\\''/g;
6887            s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
# Line 13410 | Line 6903 | if diff "$cache_file" confcache >/dev/null 2>&1; then
6903       :end' >>confcache
6904   if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
6905    if test -w "$cache_file"; then
6906 <    test "x$cache_file" != "x/dev/null" &&
6907 <      { $as_echo "$as_me:$LINENO: updating cache $cache_file" >&5
6906 >    if test "x$cache_file" != "x/dev/null"; then
6907 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
6908   $as_echo "$as_me: updating cache $cache_file" >&6;}
6909 <    cat confcache >$cache_file
6909 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
6910 >        cat confcache >"$cache_file"
6911 >      else
6912 >        case $cache_file in #(
6913 >        */* | ?:*)
6914 >          mv -f confcache "$cache_file"$$ &&
6915 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
6916 >        *)
6917 >          mv -f confcache "$cache_file" ;;
6918 >        esac
6919 >      fi
6920 >    fi
6921    else
6922 <    { $as_echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
6922 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
6923   $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
6924    fi
6925   fi
# Line 13429 | Line 6933 | ac_ltlibobjs=
6933  
6934   ac_libobjs=
6935   ac_ltlibobjs=
6936 + U=
6937   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
6938    # 1. Remove the extension, and $U if already installed.
6939    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
6940    ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
6941    # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
6942    #    will be set to the directory where LIBOBJS objects are built.
6943 <  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
6944 <  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
6943 >  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
6944 >  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
6945   done
6946   LIBOBJS=$ac_libobjs
6947  
# Line 13444 | Line 6949 | LTLIBOBJS=$ac_ltlibobjs
6949  
6950  
6951  
6952 < : ${CONFIG_STATUS=./config.status}
6952 > : "${CONFIG_STATUS=./config.status}"
6953   ac_write_fail=0
6954   ac_clean_files_save=$ac_clean_files
6955   ac_clean_files="$ac_clean_files $CONFIG_STATUS"
6956 < { $as_echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
6956 > { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
6957   $as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
6958 < cat >$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
6958 > as_write_fail=0
6959 > cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
6960   #! $SHELL
6961   # Generated by $as_me.
6962   # Run this file to recreate the current configuration.
# Line 13460 | Line 6966 | ac_cs_silent=false
6966   debug=false
6967   ac_cs_recheck=false
6968   ac_cs_silent=false
6969 +
6970   SHELL=\${CONFIG_SHELL-$SHELL}
6971 < _ACEOF
6971 > export SHELL
6972 > _ASEOF
6973 > cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
6974 > ## -------------------- ##
6975 > ## M4sh Initialization. ##
6976 > ## -------------------- ##
6977  
13466 – cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
13467 – ## --------------------- ##
13468 – ## M4sh Initialization.  ##
13469 – ## --------------------- ##
13470 –
6978   # Be more Bourne compatible
6979   DUALCASE=1; export DUALCASE # for MKS sh
6980 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
6980 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
6981    emulate sh
6982    NULLCMD=:
6983    # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
# Line 13478 | Line 6985 | else
6985    alias -g '${1+"$@"}'='"$@"'
6986    setopt NO_GLOB_SUBST
6987   else
6988 <  case `(set -o) 2>/dev/null` in
6989 <  *posix*) set -o posix ;;
6988 >  case `(set -o) 2>/dev/null` in #(
6989 >  *posix*) :
6990 >    set -o posix ;; #(
6991 >  *) :
6992 >     ;;
6993   esac
13484 –
6994   fi
6995  
6996  
13488 –
13489 –
13490 – # PATH needs CR
13491 – # Avoid depending upon Character Ranges.
13492 – as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13493 – as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13494 – as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13495 – as_cr_digits='0123456789'
13496 – as_cr_alnum=$as_cr_Letters$as_cr_digits
13497 –
6997   as_nl='
6998   '
6999   export as_nl
# Line 13502 | Line 7001 | as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_ec
7001   as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
7002   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
7003   as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
7004 < if (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
7004 > # Prefer a ksh shell builtin over an external printf program on Solaris,
7005 > # but without wasting forks for bash or zsh.
7006 > if test -z "$BASH_VERSION$ZSH_VERSION" \
7007 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
7008 >  as_echo='print -r --'
7009 >  as_echo_n='print -rn --'
7010 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
7011    as_echo='printf %s\n'
7012    as_echo_n='printf %s'
7013   else
# Line 13513 | Line 7018 | else
7018      as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
7019      as_echo_n_body='eval
7020        arg=$1;
7021 <      case $arg in
7021 >      case $arg in #(
7022        *"$as_nl"*)
7023          expr "X$arg" : "X\\(.*\\)$as_nl";
7024          arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
# Line 13536 | Line 7041 | fi
7041    }
7042   fi
7043  
13539 – # Support unset when possible.
13540 – if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13541 –  as_unset=unset
13542 – else
13543 –  as_unset=false
13544 – fi
7044  
13546 –
7045   # IFS
7046   # We need space, tab and new line, in precisely that order.  Quoting is
7047   # there to prevent editors from complaining about space-tab.
# Line 13552 | Line 7050 | IFS=" ""       $as_nl"
7050   IFS=" ""        $as_nl"
7051  
7052   # Find who we are.  Look in the path if we contain no directory separator.
7053 < case $0 in
7053 > as_myself=
7054 > case $0 in #((
7055    *[\\/]* ) as_myself=$0 ;;
7056    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7057   for as_dir in $PATH
7058   do
7059    IFS=$as_save_IFS
7060    test -z "$as_dir" && as_dir=.
7061 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7062 < done
7061 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7062 >  done
7063   IFS=$as_save_IFS
7064  
7065       ;;
# Line 13572 | Line 7071 | if test ! -f "$as_myself"; then
7071   fi
7072   if test ! -f "$as_myself"; then
7073    $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
7074 <  { (exit 1); exit 1; }
7074 >  exit 1
7075   fi
7076  
7077 < # Work around bugs in pre-3.0 UWIN ksh.
7078 < for as_var in ENV MAIL MAILPATH
7079 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
7077 > # Unset variables that we do not need and which cause bugs (e.g. in
7078 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
7079 > # suppresses any "Segmentation fault" message there.  '((' could
7080 > # trigger a bug in pdksh 5.2.14.
7081 > for as_var in BASH_ENV ENV MAIL MAILPATH
7082 > do eval test x\${$as_var+set} = xset \
7083 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
7084   done
7085   PS1='$ '
7086   PS2='> '
# Line 13589 | Line 7092 | export LANGUAGE
7092   LANGUAGE=C
7093   export LANGUAGE
7094  
7095 < # Required to use basename.
7095 > # CDPATH.
7096 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
7097 >
7098 >
7099 > # as_fn_error STATUS ERROR [LINENO LOG_FD]
7100 > # ----------------------------------------
7101 > # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
7102 > # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
7103 > # script with STATUS, using 1 if that was 0.
7104 > as_fn_error ()
7105 > {
7106 >  as_status=$1; test $as_status -eq 0 && as_status=1
7107 >  if test "$4"; then
7108 >    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
7109 >    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
7110 >  fi
7111 >  $as_echo "$as_me: error: $2" >&2
7112 >  as_fn_exit $as_status
7113 > } # as_fn_error
7114 >
7115 >
7116 > # as_fn_set_status STATUS
7117 > # -----------------------
7118 > # Set $? to STATUS, without forking.
7119 > as_fn_set_status ()
7120 > {
7121 >  return $1
7122 > } # as_fn_set_status
7123 >
7124 > # as_fn_exit STATUS
7125 > # -----------------
7126 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
7127 > as_fn_exit ()
7128 > {
7129 >  set +e
7130 >  as_fn_set_status $1
7131 >  exit $1
7132 > } # as_fn_exit
7133 >
7134 > # as_fn_unset VAR
7135 > # ---------------
7136 > # Portably unset VAR.
7137 > as_fn_unset ()
7138 > {
7139 >  { eval $1=; unset $1;}
7140 > }
7141 > as_unset=as_fn_unset
7142 > # as_fn_append VAR VALUE
7143 > # ----------------------
7144 > # Append the text in VALUE to the end of the definition contained in VAR. Take
7145 > # advantage of any shell optimizations that allow amortized linear growth over
7146 > # repeated appends, instead of the typical quadratic growth present in naive
7147 > # implementations.
7148 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
7149 >  eval 'as_fn_append ()
7150 >  {
7151 >    eval $1+=\$2
7152 >  }'
7153 > else
7154 >  as_fn_append ()
7155 >  {
7156 >    eval $1=\$$1\$2
7157 >  }
7158 > fi # as_fn_append
7159 >
7160 > # as_fn_arith ARG...
7161 > # ------------------
7162 > # Perform arithmetic evaluation on the ARGs, and store the result in the
7163 > # global $as_val. Take advantage of shells that can avoid forks. The arguments
7164 > # must be portable across $(()) and expr.
7165 > if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
7166 >  eval 'as_fn_arith ()
7167 >  {
7168 >    as_val=$(( $* ))
7169 >  }'
7170 > else
7171 >  as_fn_arith ()
7172 >  {
7173 >    as_val=`expr "$@" || test $? -eq 1`
7174 >  }
7175 > fi # as_fn_arith
7176 >
7177 >
7178   if expr a : '\(a\)' >/dev/null 2>&1 &&
7179     test "X`expr 00001 : '.*\(...\)'`" = X001; then
7180    as_expr=expr
# Line 13603 | Line 7188 | fi
7188    as_basename=false
7189   fi
7190  
7191 + if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
7192 +  as_dirname=dirname
7193 + else
7194 +  as_dirname=false
7195 + fi
7196  
13607 – # Name of the executable.
7197   as_me=`$as_basename -- "$0" ||
7198   $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
7199           X"$0" : 'X\(//\)$' \| \
# Line 13624 | Line 7213 | $as_echo X/"$0" |
7213            }
7214            s/.*/./; q'`
7215  
7216 < # CDPATH.
7217 < $as_unset CDPATH
7216 > # Avoid depending upon Character Ranges.
7217 > as_cr_letters='abcdefghijklmnopqrstuvwxyz'
7218 > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
7219 > as_cr_Letters=$as_cr_letters$as_cr_LETTERS
7220 > as_cr_digits='0123456789'
7221 > as_cr_alnum=$as_cr_Letters$as_cr_digits
7222  
13630 –
13631 –
13632 –  as_lineno_1=$LINENO
13633 –  as_lineno_2=$LINENO
13634 –  test "x$as_lineno_1" != "x$as_lineno_2" &&
13635 –  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
13636 –
13637 –  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13638 –  # uniformly replaced by the line number.  The first 'sed' inserts a
13639 –  # line-number line after each line using $LINENO; the second 'sed'
13640 –  # does the real work.  The second script uses 'N' to pair each
13641 –  # line-number line with the line containing $LINENO, and appends
13642 –  # trailing '-' during substitution so that $LINENO is not a special
13643 –  # case at line end.
13644 –  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13645 –  # scripts with optimization help from Paolo Bonzini.  Blame Lee
13646 –  # E. McMahon (1931-1989) for sed's syntax.  :-)
13647 –  sed -n '
13648 –    p
13649 –    /[$]LINENO/=
13650 –  ' <$as_myself |
13651 –    sed '
13652 –      s/[$]LINENO.*/&-/
13653 –      t lineno
13654 –      b
13655 –      :lineno
13656 –      N
13657 –      :loop
13658 –      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
13659 –      t loop
13660 –      s/-\n.*//
13661 –    ' >$as_me.lineno &&
13662 –  chmod +x "$as_me.lineno" ||
13663 –    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
13664 –   { (exit 1); exit 1; }; }
13665 –
13666 –  # Don't try to exec as it changes $[0], causing all sort of problems
13667 –  # (the dirname of $[0] is not the place where we might find the
13668 –  # original and so on.  Autoconf is especially sensitive to this).
13669 –  . "./$as_me.lineno"
13670 –  # Exit status is that of the last command.
13671 –  exit
13672 – }
13673 –
13674 –
13675 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
13676 –  as_dirname=dirname
13677 – else
13678 –  as_dirname=false
13679 – fi
13680 –
7223   ECHO_C= ECHO_N= ECHO_T=
7224 < case `echo -n x` in
7224 > case `echo -n x` in #(((((
7225   -n*)
7226 <  case `echo 'x\c'` in
7226 >  case `echo 'xy\c'` in
7227    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
7228 <  *)   ECHO_C='\c';;
7228 >  xy)  ECHO_C='\c';;
7229 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
7230 >       ECHO_T=' ';;
7231    esac;;
7232   *)
7233    ECHO_N='-n';;
7234   esac
13691 – if expr a : '\(a\)' >/dev/null 2>&1 &&
13692 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
13693 –  as_expr=expr
13694 – else
13695 –  as_expr=false
13696 – fi
7235  
7236   rm -f conf$$ conf$$.exe conf$$.file
7237   if test -d conf$$.dir; then
# Line 13722 | Line 7260 | rmdir conf$$.dir 2>/dev/null
7260   rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
7261   rmdir conf$$.dir 2>/dev/null
7262  
7263 +
7264 + # as_fn_mkdir_p
7265 + # -------------
7266 + # Create "$as_dir" as a directory, including parents if necessary.
7267 + as_fn_mkdir_p ()
7268 + {
7269 +
7270 +  case $as_dir in #(
7271 +  -*) as_dir=./$as_dir;;
7272 +  esac
7273 +  test -d "$as_dir" || eval $as_mkdir_p || {
7274 +    as_dirs=
7275 +    while :; do
7276 +      case $as_dir in #(
7277 +      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
7278 +      *) as_qdir=$as_dir;;
7279 +      esac
7280 +      as_dirs="'$as_qdir' $as_dirs"
7281 +      as_dir=`$as_dirname -- "$as_dir" ||
7282 + $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
7283 +         X"$as_dir" : 'X\(//\)[^/]' \| \
7284 +         X"$as_dir" : 'X\(//\)$' \| \
7285 +         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
7286 + $as_echo X"$as_dir" |
7287 +    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
7288 +            s//\1/
7289 +            q
7290 +          }
7291 +          /^X\(\/\/\)[^/].*/{
7292 +            s//\1/
7293 +            q
7294 +          }
7295 +          /^X\(\/\/\)$/{
7296 +            s//\1/
7297 +            q
7298 +          }
7299 +          /^X\(\/\).*/{
7300 +            s//\1/
7301 +            q
7302 +          }
7303 +          s/.*/./; q'`
7304 +      test -d "$as_dir" && break
7305 +    done
7306 +    test -z "$as_dirs" || eval "mkdir $as_dirs"
7307 +  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
7308 +
7309 +
7310 + } # as_fn_mkdir_p
7311   if mkdir -p . 2>/dev/null; then
7312 <  as_mkdir_p=:
7312 >  as_mkdir_p='mkdir -p "$as_dir"'
7313   else
7314    test -d ./-p && rmdir ./-p
7315    as_mkdir_p=false
# Line 13742 | Line 7328 | else
7328        if test -d "$1"; then
7329          test -d "$1/.";
7330        else
7331 <        case $1 in
7331 >        case $1 in #(
7332          -*)set "./$1";;
7333          esac;
7334 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
7334 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
7335          ???[sx]*):;;*)false;;esac;fi
7336      '\'' sh
7337    '
# Line 13760 | Line 7346 | exec 6>&1
7346  
7347  
7348   exec 6>&1
7349 + ## ----------------------------------- ##
7350 + ## Main body of $CONFIG_STATUS script. ##
7351 + ## ----------------------------------- ##
7352 + _ASEOF
7353 + test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
7354  
7355 < # Save the log message, to keep $[0] and so on meaningful, and to
7355 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7356 > # Save the log message, to keep $0 and so on meaningful, and to
7357   # report actual input values of CONFIG_FILES etc. instead of their
7358   # values after options handling.
7359   ac_log="
7360 < This file was extended by OOPSE $as_me 4.0, which was
7361 < generated by GNU Autoconf 2.62.  Invocation command line was
7360 > This file was extended by OpenMD $as_me 2.0, which was
7361 > generated by GNU Autoconf 2.68.  Invocation command line was
7362  
7363    CONFIG_FILES    = $CONFIG_FILES
7364    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 13779 | Line 7371 | _ACEOF
7371  
7372   _ACEOF
7373  
7374 + case $ac_config_files in *"
7375 + "*) set x $ac_config_files; shift; ac_config_files=$*;;
7376 + esac
7377 +
7378 + case $ac_config_headers in *"
7379 + "*) set x $ac_config_headers; shift; ac_config_headers=$*;;
7380 + esac
7381 +
7382 +
7383   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7384   # Files that config.status was made for.
7385   config_files="$ac_config_files"
# Line 13788 | Line 7389 | ac_cs_usage="\
7389  
7390   cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7391   ac_cs_usage="\
7392 < \`$as_me' instantiates files from templates according to the
7393 < current configuration.
7392 > \`$as_me' instantiates files and other configuration actions
7393 > from templates according to the current configuration.  Unless the files
7394 > and actions are specified as TAGs, all are instantiated by default.
7395  
7396 < Usage: $0 [OPTIONS] [FILE]...
7396 > Usage: $0 [OPTION]... [TAG]...
7397  
7398    -h, --help       print this help, then exit
7399    -V, --version    print version number and configuration settings, then exit
7400 <  -q, --quiet      do not print progress messages
7400 >      --config     print configuration, then exit
7401 >  -q, --quiet, --silent
7402 >                   do not print progress messages
7403    -d, --debug      don't remove temporary files
7404        --recheck    update $as_me by reconfiguring in the same conditions
7405 <  --file=FILE[:TEMPLATE]
7405 >      --file=FILE[:TEMPLATE]
7406                     instantiate the configuration file FILE
7407 <  --header=FILE[:TEMPLATE]
7407 >      --header=FILE[:TEMPLATE]
7408                     instantiate the configuration header FILE
7409  
7410   Configuration files:
# Line 13809 | Line 7413 | $config_headers
7413   Configuration headers:
7414   $config_headers
7415  
7416 < Report bugs to <bug-autoconf@gnu.org>."
7416 > Report bugs to <gezelter@nd.edu>."
7417  
7418   _ACEOF
7419   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7420 + ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
7421   ac_cs_version="\\
7422 < OOPSE config.status 4.0
7423 < configured by $0, generated by GNU Autoconf 2.62,
7424 <  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
7422 > OpenMD config.status 2.0
7423 > configured by $0, generated by GNU Autoconf 2.68,
7424 >  with options \\"\$ac_cs_config\\"
7425  
7426 < Copyright (C) 2008 Free Software Foundation, Inc.
7426 > Copyright (C) 2010 Free Software Foundation, Inc.
7427   This config.status script is free software; the Free Software Foundation
7428   gives unlimited permission to copy, distribute and modify it."
7429  
# Line 13834 | Line 7439 | do
7439   while test $# != 0
7440   do
7441    case $1 in
7442 <  --*=*)
7442 >  --*=?*)
7443      ac_option=`expr "X$1" : 'X\([^=]*\)='`
7444      ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
7445      ac_shift=:
7446      ;;
7447 +  --*=)
7448 +    ac_option=`expr "X$1" : 'X\([^=]*\)='`
7449 +    ac_optarg=
7450 +    ac_shift=:
7451 +    ;;
7452    *)
7453      ac_option=$1
7454      ac_optarg=$2
# Line 13852 | Line 7462 | do
7462      ac_cs_recheck=: ;;
7463    --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
7464      $as_echo "$ac_cs_version"; exit ;;
7465 +  --config | --confi | --conf | --con | --co | --c )
7466 +    $as_echo "$ac_cs_config"; exit ;;
7467    --debug | --debu | --deb | --de | --d | -d )
7468      debug=: ;;
7469    --file | --fil | --fi | --f )
7470      $ac_shift
7471      case $ac_optarg in
7472      *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7473 +    '') as_fn_error $? "missing file argument" ;;
7474      esac
7475 <    CONFIG_FILES="$CONFIG_FILES '$ac_optarg'"
7475 >    as_fn_append CONFIG_FILES " '$ac_optarg'"
7476      ac_need_defaults=false;;
7477    --header | --heade | --head | --hea )
7478      $ac_shift
7479      case $ac_optarg in
7480      *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7481      esac
7482 <    CONFIG_HEADERS="$CONFIG_HEADERS '$ac_optarg'"
7482 >    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
7483      ac_need_defaults=false;;
7484    --he | --h)
7485      # Conflict between --help and --header
7486 <    { $as_echo "$as_me: error: ambiguous option: $1
7487 < Try \`$0 --help' for more information." >&2
13875 <   { (exit 1); exit 1; }; };;
7486 >    as_fn_error $? "ambiguous option: \`$1'
7487 > Try \`$0 --help' for more information.";;
7488    --help | --hel | -h )
7489      $as_echo "$ac_cs_usage"; exit ;;
7490    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
# Line 13880 | Line 7492 | Try \`$0 --help' for more information." >&2
7492      ac_cs_silent=: ;;
7493  
7494    # This is an error.
7495 <  -*) { $as_echo "$as_me: error: unrecognized option: $1
7496 < Try \`$0 --help' for more information." >&2
13885 <   { (exit 1); exit 1; }; } ;;
7495 >  -*) as_fn_error $? "unrecognized option: \`$1'
7496 > Try \`$0 --help' for more information." ;;
7497  
7498 <  *) ac_config_targets="$ac_config_targets $1"
7498 >  *) as_fn_append ac_config_targets " $1"
7499       ac_need_defaults=false ;;
7500  
7501    esac
# Line 13938 | Line 7549 | do
7549      "src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
7550      "scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
7551  
7552 <  *) { { $as_echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13942 < $as_echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13943 <   { (exit 1); exit 1; }; };;
7552 >  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
7553    esac
7554   done
7555  
# Line 13962 | Line 7571 | $debug ||
7571   # after its creation but before its name has been assigned to `$tmp'.
7572   $debug ||
7573   {
7574 <  tmp=
7574 >  tmp= ac_tmp=
7575    trap 'exit_status=$?
7576 <  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
7576 >  : "${ac_tmp:=$tmp}"
7577 >  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
7578   ' 0
7579 <  trap '{ (exit 1); exit 1; }' 1 2 13 15
7579 >  trap 'as_fn_exit 1' 1 2 13 15
7580   }
7581   # Create a (secure) tmp directory for tmp files.
7582  
7583   {
7584    tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
7585 <  test -n "$tmp" && test -d "$tmp"
7585 >  test -d "$tmp"
7586   }  ||
7587   {
7588    tmp=./conf$$-$RANDOM
7589    (umask 077 && mkdir "$tmp")
7590 < } ||
7591 < {
13982 <   $as_echo "$as_me: cannot create a temporary directory in ." >&2
13983 <   { (exit 1); exit 1; }
13984 < }
7590 > } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
7591 > ac_tmp=$tmp
7592  
7593   # Set up the scripts for CONFIG_FILES section.
7594   # No need to generate them if there are no CONFIG_FILES.
# Line 13989 | Line 7596 | if test -n "$CONFIG_FILES"; then
7596   if test -n "$CONFIG_FILES"; then
7597  
7598  
7599 < ac_cr='
7600 < '
7599 > ac_cr=`echo X | tr X '\015'`
7600 > # On cygwin, bash can eat \r inside `` if the user requested igncr.
7601 > # But we know of no other shell where ac_cr would be empty at this
7602 > # point, so we can use a bashism as a fallback.
7603 > if test "x$ac_cr" = x; then
7604 >  eval ac_cr=\$\'\\r\'
7605 > fi
7606   ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
7607   if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
7608    ac_cs_awk_cr='\\r'
# Line 13998 | Line 7610 | fi
7610    ac_cs_awk_cr=$ac_cr
7611   fi
7612  
7613 < echo 'BEGIN {' >"$tmp/subs1.awk" &&
7613 > echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
7614   _ACEOF
7615  
7616  
# Line 14007 | Line 7619 | _ACEOF
7619    echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
7620    echo "_ACEOF"
7621   } >conf$$subs.sh ||
7622 <  { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
7623 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14012 <   { (exit 1); exit 1; }; }
14013 < ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'`
7622 >  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
7623 > ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
7624   ac_delim='%!_!# '
7625   for ac_last_try in false false false false false :; do
7626    . ./conf$$subs.sh ||
7627 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14018 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14019 <   { (exit 1); exit 1; }; }
7627 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
7628  
7629 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` = $ac_delim_num; then
7629 >  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
7630 >  if test $ac_delim_n = $ac_delim_num; then
7631      break
7632    elif $ac_last_try; then
7633 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
14025 < $as_echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
14026 <   { (exit 1); exit 1; }; }
7633 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
7634    else
7635      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
7636    fi
# Line 14031 | Line 7638 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7638   rm -f conf$$subs.sh
7639  
7640   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7641 < cat >>"\$tmp/subs1.awk" <<\\_ACAWK &&
7641 > cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
7642   _ACEOF
7643   sed -n '
7644   h
# Line 14045 | Line 7652 | h
7652   t delim
7653   :nl
7654   h
7655 < s/\(.\{148\}\).*/\1/
7655 > s/\(.\{148\}\)..*/\1/
7656   t more1
7657   s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
7658   p
# Line 14059 | Line 7666 | h
7666   t nl
7667   :delim
7668   h
7669 < s/\(.\{148\}\).*/\1/
7669 > s/\(.\{148\}\)..*/\1/
7670   t more2
7671   s/["\\]/\\&/g; s/^/"/; s/$/"/
7672   p
# Line 14079 | Line 7686 | _ACAWK
7686   rm -f conf$$subs.awk
7687   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7688   _ACAWK
7689 < cat >>"\$tmp/subs1.awk" <<_ACAWK &&
7689 > cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
7690    for (key in S) S_is_set[key] = 1
7691    FS = ""
7692  
# Line 14111 | Line 7718 | else
7718    sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
7719   else
7720    cat
7721 < fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
7722 <  || { { $as_echo "$as_me:$LINENO: error: could not setup config files machinery" >&5
14116 < $as_echo "$as_me: error: could not setup config files machinery" >&2;}
14117 <   { (exit 1); exit 1; }; }
7721 > fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
7722 >  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
7723   _ACEOF
7724  
7725 < # VPATH may cause trouble with some makes, so we remove $(srcdir),
7726 < # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
7725 > # VPATH may cause trouble with some makes, so we remove sole $(srcdir),
7726 > # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
7727   # trailing colons and then remove the whole line if VPATH becomes empty
7728   # (actually we leave an empty line to preserve line numbers).
7729   if test "x$srcdir" = x.; then
7730 <  ac_vpsub='/^[  ]*VPATH[        ]*=/{
7731 < s/:*\$(srcdir):*/:/
7732 < s/:*\${srcdir}:*/:/
7733 < s/:*@srcdir@:*/:/
7734 < s/^\([^=]*=[     ]*\):*/\1/
7730 >  ac_vpsub='/^[  ]*VPATH[        ]*=[    ]*/{
7731 > h
7732 > s///
7733 > s/^/:/
7734 > s/[      ]*$/:/
7735 > s/:\$(srcdir):/:/g
7736 > s/:\${srcdir}:/:/g
7737 > s/:@srcdir@:/:/g
7738 > s/^:*//
7739   s/:*$//
7740 + x
7741 + s/\(=[   ]*\).*/\1/
7742 + G
7743 + s/\n//
7744   s/^[^=]*=[       ]*$//
7745   }'
7746   fi
# Line 14139 | Line 7752 | if test -n "$CONFIG_HEADERS"; then
7752   # No need to generate them if there are no CONFIG_HEADERS.
7753   # This happens for instance with `./config.status Makefile'.
7754   if test -n "$CONFIG_HEADERS"; then
7755 < cat >"$tmp/defines.awk" <<\_ACAWK ||
7755 > cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
7756   BEGIN {
7757   _ACEOF
7758  
# Line 14151 | Line 7764 | for ac_last_try in false false :; do
7764   # handling of long lines.
7765   ac_delim='%!_!# '
7766   for ac_last_try in false false :; do
7767 <  ac_t=`sed -n "/$ac_delim/p" confdefs.h`
7768 <  if test -z "$ac_t"; then
7767 >  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
7768 >  if test -z "$ac_tt"; then
7769      break
7770    elif $ac_last_try; then
7771 <    { { $as_echo "$as_me:$LINENO: error: could not make $CONFIG_HEADERS" >&5
14159 < $as_echo "$as_me: error: could not make $CONFIG_HEADERS" >&2;}
14160 <   { (exit 1); exit 1; }; }
7771 >    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
7772    else
7773      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
7774    fi
# Line 14223 | Line 7834 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7834    }
7835    split(mac1, mac2, "(") #)
7836    macro = mac2[1]
7837 +  prefix = substr(line, 1, index(line, defundef) - 1)
7838    if (D_is_set[macro]) {
7839      # Preserve the white space surrounding the "#".
14228 –    prefix = substr(line, 1, index(line, defundef) - 1)
7840      print prefix "define", macro P[macro] D[macro]
7841      next
7842    } else {
# Line 14233 | Line 7844 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7844      # in the case of _POSIX_SOURCE, which is predefined and required
7845      # on some systems where configure will not decide to define it.
7846      if (defundef == "undef") {
7847 <      print "/*", line, "*/"
7847 >      print "/*", prefix defundef, macro, "*/"
7848        next
7849      }
7850    }
# Line 14242 | Line 7853 | cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7853   _ACAWK
7854   _ACEOF
7855   cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7856 <  { { $as_echo "$as_me:$LINENO: error: could not setup config headers machinery" >&5
14246 < $as_echo "$as_me: error: could not setup config headers machinery" >&2;}
14247 <   { (exit 1); exit 1; }; }
7856 >  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
7857   fi # test -n "$CONFIG_HEADERS"
7858  
7859  
# Line 14257 | Line 7866 | do
7866    esac
7867    case $ac_mode$ac_tag in
7868    :[FHL]*:*);;
7869 <  :L* | :C*:*) { { $as_echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
14261 < $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
14262 <   { (exit 1); exit 1; }; };;
7869 >  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
7870    :[FH]-) ac_tag=-:-;;
7871    :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
7872    esac
# Line 14278 | Line 7885 | $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
7885      for ac_f
7886      do
7887        case $ac_f in
7888 <      -) ac_f="$tmp/stdin";;
7888 >      -) ac_f="$ac_tmp/stdin";;
7889        *) # Look for the file first in the build tree, then in the source tree
7890           # (if the path is not absolute).  The absolute path cannot be DOS-style,
7891           # because $ac_f cannot contain `:'.
# Line 14287 | Line 7894 | $as_echo "$as_me: error: Invalid tag $ac_tag." >&2;}
7894             [\\/$]*) false;;
7895             *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
7896             esac ||
7897 <           { { $as_echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
14291 < $as_echo "$as_me: error: cannot find input file: $ac_f" >&2;}
14292 <   { (exit 1); exit 1; }; };;
7897 >           as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
7898        esac
7899        case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
7900 <      ac_file_inputs="$ac_file_inputs '$ac_f'"
7900 >      as_fn_append ac_file_inputs " '$ac_f'"
7901      done
7902  
7903      # Let's still pretend it is `configure' which instantiates (i.e., don't
# Line 14303 | Line 7908 | $as_echo "$as_me: error: cannot find input file: $ac_f
7908          `' by configure.'
7909      if test x"$ac_file" != x-; then
7910        configure_input="$ac_file.  $configure_input"
7911 <      { $as_echo "$as_me:$LINENO: creating $ac_file" >&5
7911 >      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
7912   $as_echo "$as_me: creating $ac_file" >&6;}
7913      fi
7914      # Neutralize special characters interpreted by sed in replacement strings.
# Line 14315 | Line 7920 | $as_echo "$as_me: creating $ac_file" >&6;}
7920      esac
7921  
7922      case $ac_tag in
7923 <    *:-:* | *:-) cat >"$tmp/stdin" \
7924 <      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14320 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14321 <   { (exit 1); exit 1; }; } ;;
7923 >    *:-:* | *:-) cat >"$ac_tmp/stdin" \
7924 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
7925      esac
7926      ;;
7927    esac
# Line 14329 | Line 7932 | $as_echo X"$ac_file" |
7932           X"$ac_file" : 'X\(//\)$' \| \
7933           X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
7934   $as_echo X"$ac_file" |
14332 –    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
14333 –            s//\1/
14334 –            q
14335 –          }
14336 –          /^X\(\/\/\)[^/].*/{
14337 –            s//\1/
14338 –            q
14339 –          }
14340 –          /^X\(\/\/\)$/{
14341 –            s//\1/
14342 –            q
14343 –          }
14344 –          /^X\(\/\).*/{
14345 –            s//\1/
14346 –            q
14347 –          }
14348 –          s/.*/./; q'`
14349 –  { as_dir="$ac_dir"
14350 –  case $as_dir in #(
14351 –  -*) as_dir=./$as_dir;;
14352 –  esac
14353 –  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
14354 –    as_dirs=
14355 –    while :; do
14356 –      case $as_dir in #(
14357 –      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
14358 –      *) as_qdir=$as_dir;;
14359 –      esac
14360 –      as_dirs="'$as_qdir' $as_dirs"
14361 –      as_dir=`$as_dirname -- "$as_dir" ||
14362 – $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
14363 –         X"$as_dir" : 'X\(//\)[^/]' \| \
14364 –         X"$as_dir" : 'X\(//\)$' \| \
14365 –         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
14366 – $as_echo X"$as_dir" |
7935      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
7936              s//\1/
7937              q
# Line 14381 | Line 7949 | $as_echo X"$as_dir" |
7949              q
7950            }
7951            s/.*/./; q'`
7952 <      test -d "$as_dir" && break
14385 <    done
14386 <    test -z "$as_dirs" || eval "mkdir $as_dirs"
14387 <  } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
14388 < $as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
14389 <   { (exit 1); exit 1; }; }; }
7952 >  as_dir="$ac_dir"; as_fn_mkdir_p
7953    ac_builddir=.
7954  
7955   case "$ac_dir" in
# Line 14438 | Line 8001 | ac_datarootdir_hack=; ac_datarootdir_seen=
8001   # If the template does not know about datarootdir, expand it.
8002   # FIXME: This hack should be removed a few years after 2.60.
8003   ac_datarootdir_hack=; ac_datarootdir_seen=
14441 –
8004   ac_sed_dataroot='
8005   /datarootdir/ {
8006    p
# Line 14448 | Line 8010 | ac_sed_dataroot='
8010   /@docdir@/p
8011   /@infodir@/p
8012   /@localedir@/p
8013 < /@mandir@/p
14452 < '
8013 > /@mandir@/p'
8014   case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
8015   *datarootdir*) ac_datarootdir_seen=yes;;
8016   *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
8017 <  { $as_echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8017 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8018   $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
8019   _ACEOF
8020   cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
# Line 14463 | Line 8024 | cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8024    s&@infodir@&$infodir&g
8025    s&@localedir@&$localedir&g
8026    s&@mandir@&$mandir&g
8027 <    s&\\\${datarootdir}&$datarootdir&g' ;;
8027 >  s&\\\${datarootdir}&$datarootdir&g' ;;
8028   esac
8029   _ACEOF
8030  
# Line 14490 | Line 8051 | $ac_datarootdir_hack
8051   s&@INSTALL@&$ac_INSTALL&;t t
8052   $ac_datarootdir_hack
8053   "
8054 < eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
8055 <  || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14495 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14496 <   { (exit 1); exit 1; }; }
8054 > eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
8055 >  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8056  
8057   test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
8058 <  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
8059 <  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
8060 <  { $as_echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8061 < which seems to be undefined.  Please make sure it is defined." >&5
8058 >  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
8059 >  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' \
8060 >      "$ac_tmp/out"`; test -z "$ac_out"; } &&
8061 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8062 > which seems to be undefined.  Please make sure it is defined" >&5
8063   $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8064 < which seems to be undefined.  Please make sure it is defined." >&2;}
8064 > which seems to be undefined.  Please make sure it is defined" >&2;}
8065  
8066 <  rm -f "$tmp/stdin"
8066 >  rm -f "$ac_tmp/stdin"
8067    case $ac_file in
8068 <  -) cat "$tmp/out" && rm -f "$tmp/out";;
8069 <  *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
8068 >  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
8069 >  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
8070    esac \
8071 <  || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14512 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14513 <   { (exit 1); exit 1; }; }
8071 >  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8072   ;;
8073    :H)
8074    #
# Line 14519 | Line 8077 | $as_echo "$as_me: error: could not create $ac_file" >&
8077    if test x"$ac_file" != x-; then
8078      {
8079        $as_echo "/* $configure_input  */" \
8080 <      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
8081 <    } >"$tmp/config.h" \
8082 <      || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
8083 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
8084 <   { (exit 1); exit 1; }; }
14527 <    if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
14528 <      { $as_echo "$as_me:$LINENO: $ac_file is unchanged" >&5
8080 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
8081 >    } >"$ac_tmp/config.h" \
8082 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8083 >    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
8084 >      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
8085   $as_echo "$as_me: $ac_file is unchanged" >&6;}
8086      else
8087        rm -f "$ac_file"
8088 <      mv "$tmp/config.h" "$ac_file" \
8089 <        || { { $as_echo "$as_me:$LINENO: error: could not create $ac_file" >&5
14534 < $as_echo "$as_me: error: could not create $ac_file" >&2;}
14535 <   { (exit 1); exit 1; }; }
8088 >      mv "$ac_tmp/config.h" "$ac_file" \
8089 >        || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8090      fi
8091    else
8092      $as_echo "/* $configure_input  */" \
8093 <      && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
8094 <      || { { $as_echo "$as_me:$LINENO: error: could not create -" >&5
14541 < $as_echo "$as_me: error: could not create -" >&2;}
14542 <   { (exit 1); exit 1; }; }
8093 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
8094 >      || as_fn_error $? "could not create -" "$LINENO" 5
8095    fi
8096   ;;
8097  
# Line 14559 | Line 8111 | done # for ac_tag
8111   done # for ac_tag
8112  
8113  
8114 < { (exit 0); exit 0; }
8114 > as_fn_exit 0
8115   _ACEOF
14564 – chmod +x $CONFIG_STATUS
8116   ac_clean_files=$ac_clean_files_save
8117  
8118   test $ac_write_fail = 0 ||
8119 <  { { $as_echo "$as_me:$LINENO: error: write failure creating $CONFIG_STATUS" >&5
14569 < $as_echo "$as_me: error: write failure creating $CONFIG_STATUS" >&2;}
14570 <   { (exit 1); exit 1; }; }
8119 >  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
8120  
8121  
8122   # configure is writing to config.log, and then calls config.status.
# Line 14588 | Line 8137 | if test "$no_create" != yes; then
8137    exec 5>>config.log
8138    # Use ||, not &&, to avoid exiting from the if with $? = 1, which
8139    # would make configure fail if this is the last instruction.
8140 <  $ac_cs_success || { (exit 1); exit 1; }
8140 >  $ac_cs_success || as_fn_exit 1
8141   fi
8142   if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
8143 <  { $as_echo "$as_me:$LINENO: WARNING: Unrecognized options: $ac_unrecognized_opts" >&5
8144 < $as_echo "$as_me: WARNING: Unrecognized options: $ac_unrecognized_opts" >&2;}
8143 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
8144 > $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
8145   fi
8146  

Diff Legend

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