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 1299 by skuang, Fri Sep 26 18:54:53 2008 UTC vs.
branches/development/configure (file contents), Revision 1618 by gezelter, Mon Sep 12 17:09:26 2011 UTC

# Line 1 | Line 1
1   #! /bin/sh
2   # Guess values for system-dependent variables and create Makefiles.
3 < # Generated by GNU Autoconf 2.61 for OOPSE 4.0.
3 > # Generated by GNU Autoconf 2.68 for OpenMD 1.0.
4   #
5   # Report bugs to <gezelter@nd.edu>.
6   #
7 + #
8   # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
9 < # 2002, 2003, 2004, 2005, 2006 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 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
24 >  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
25    # is contrary to our usage.  Disable this feature.
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  
38 <
39 <
40 < # PATH needs CR
41 < # Avoid depending upon Character Ranges.
42 < as_cr_letters='abcdefghijklmnopqrstuvwxyz'
43 < as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
44 < as_cr_Letters=$as_cr_letters$as_cr_LETTERS
45 < as_cr_digits='0123456789'
46 < as_cr_alnum=$as_cr_Letters$as_cr_digits
47 <
48 < # The user is always right.
49 < if test "${PATH_SEPARATOR+set}" != set; then
50 <  echo "#! /bin/sh" >conf$$.sh
51 <  echo  "exit 0"   >>conf$$.sh
52 <  chmod +x conf$$.sh
53 <  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
54 <    PATH_SEPARATOR=';'
38 > as_nl='
39 > '
40 > export as_nl
41 > # Printing a long string crashes Solaris 7 /usr/bin/printf.
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 > # 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
55 >  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
56 >    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
57 >    as_echo_n='/usr/ucb/echo -n'
58    else
59 <    PATH_SEPARATOR=:
59 >    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
60 >    as_echo_n_body='eval
61 >      arg=$1;
62 >      case $arg in #(
63 >      *"$as_nl"*)
64 >        expr "X$arg" : "X\\(.*\\)$as_nl";
65 >        arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
66 >      esac;
67 >      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
68 >    '
69 >    export as_echo_n_body
70 >    as_echo_n='sh -c $as_echo_n_body as_echo'
71    fi
72 <  rm -f conf$$.sh
72 >  export as_echo_body
73 >  as_echo='sh -c $as_echo_body as_echo'
74   fi
75  
76 < # Support unset when possible.
77 < if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
78 <  as_unset=unset
79 < else
80 <  as_unset=false
76 > # The user is always right.
77 > if test "${PATH_SEPARATOR+set}" != set; then
78 >  PATH_SEPARATOR=:
79 >  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
80 >    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
81 >      PATH_SEPARATOR=';'
82 >  }
83   fi
84  
85  
# Line 65 | Line 88 | fi
88   # there to prevent editors from complaining about space-tab.
89   # (If _AS_PATH_WALK were called with IFS unset, it would disable word
90   # splitting by setting IFS to empty value.)
68 – as_nl='
69 – '
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 89 | Line 111 | if test ! -f "$as_myself"; then
111    as_myself=$0
112   fi
113   if test ! -f "$as_myself"; then
114 <  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
115 <  { (exit 1); exit 1; }
114 >  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
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='> '
128   PS4='+ '
129  
130   # NLS nuisances.
131 < for as_var in \
132 <  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
133 <  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
134 <  LC_TELEPHONE LC_TIME
109 < do
110 <  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
111 <    eval $as_var=C; export $as_var
112 <  else
113 <    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
114 <  fi
115 < done
131 > LC_ALL=C
132 > export LC_ALL
133 > LANGUAGE=C
134 > export LANGUAGE
135  
117 – # Required to use basename.
118 – if expr a : '\(a\)' >/dev/null 2>&1 &&
119 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
120 –  as_expr=expr
121 – else
122 –  as_expr=false
123 – fi
124 –
125 – if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
126 –  as_basename=basename
127 – else
128 –  as_basename=false
129 – fi
130 –
131 –
132 – # Name of the executable.
133 – as_me=`$as_basename -- "$0" ||
134 – $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
135 –         X"$0" : 'X\(//\)$' \| \
136 –         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
137 – echo X/"$0" |
138 –    sed '/^.*\/\([^/][^/]*\)\/*$/{
139 –            s//\1/
140 –            q
141 –          }
142 –          /^X\/\(\/\/\)$/{
143 –            s//\1/
144 –            q
145 –          }
146 –          /^X\/\(\/\).*/{
147 –            s//\1/
148 –            q
149 –          }
150 –          s/.*/./; q'`
151 –
136   # CDPATH.
137 < $as_unset CDPATH
137 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
138  
155 –
139   if test "x$CONFIG_SHELL" = x; then
140 <  if (eval ":") 2>/dev/null; then
141 <  as_have_required=yes
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_have_required=no
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  
163 –  if test $as_have_required = yes &&     (eval ":
164 – (as_func_return () {
165 –  (exit \$1)
166 – }
167 – as_func_success () {
168 –  as_func_return 0
169 – }
170 – as_func_failure () {
171 –  as_func_return 1
172 – }
173 – as_func_ret_success () {
174 –  return 0
175 – }
176 – as_func_ret_failure () {
177 –  return 1
178 – }
179 –
162   exitcode=0
163 < if as_func_success; then
164 <  :
165 < else
166 <  exitcode=1
167 <  echo as_func_success failed.
186 < fi
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  
188 – if as_func_failure; then
189 –  exitcode=1
190 –  echo as_func_failure succeeded.
191 – fi
192 –
193 – if as_func_ret_success; then
194 –  :
169   else
170 <  exitcode=1
197 <  echo as_func_ret_success failed.
170 >  exitcode=1; echo positional parameters were not saved.
171   fi
172 <
173 < if as_func_ret_failure; then
174 <  exitcode=1
175 <  echo as_func_ret_failure succeeded.
176 < fi
177 <
178 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
179 <  :
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 <  exitcode=1
209 <  echo positional parameters were not saved.
181 >  as_have_required=no
182   fi
183 +  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
184  
212 – test \$exitcode = 0) || { (exit 1); exit 1; }
213 –
214 – (
215 –  as_lineno_1=\$LINENO
216 –  as_lineno_2=\$LINENO
217 –  test \"x\$as_lineno_1\" != \"x\$as_lineno_2\" &&
218 –  test \"x\`expr \$as_lineno_1 + 1\`\" = \"x\$as_lineno_2\") || { (exit 1); exit 1; }
219 – ") 2> /dev/null; then
220 –  :
185   else
186 <  as_candidate_shells=
187 <    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 <  # Zsh 3.x and 4.x performs 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 <
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 <
235 < :
236 < _ASEOF
237 < }; then
238 <  CONFIG_SHELL=$as_shell
239 <               as_have_required=yes
240 <               if { "$as_shell" 2> /dev/null <<\_ASEOF
241 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
242 <  emulate sh
243 <  NULLCMD=:
244 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
245 <  # is contrary to our usage.  Disable this feature.
246 <  alias -g '${1+"$@"}'='"$@"'
247 <  setopt NO_GLOB_SUBST
270 < else
271 <  case `(set -o) 2>/dev/null` in
272 <  *posix*) set -o posix ;;
273 < esac
274 <
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
276 –
277 –
278 – :
279 – (as_func_return () {
280 –  (exit $1)
281 – }
282 – as_func_success () {
283 –  as_func_return 0
284 – }
285 – as_func_failure () {
286 –  as_func_return 1
287 – }
288 – as_func_ret_success () {
289 –  return 0
290 – }
291 – as_func_ret_failure () {
292 –  return 1
293 – }
294 –
295 – exitcode=0
296 – if as_func_success; then
297 –  :
298 – else
299 –  exitcode=1
300 –  echo as_func_success failed.
249   fi
302 –
303 – if as_func_failure; then
304 –  exitcode=1
305 –  echo as_func_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 as_func_ret_success; then
258 <  :
259 < else
260 <  exitcode=1
261 <  echo as_func_ret_success failed.
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 < if as_func_ret_failure; then
270 <  exitcode=1
271 <  echo as_func_ret_failure succeeded.
272 < fi
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 < if ( set x; as_func_ret_success y && test x = "$1" ); then
278 <  :
279 < else
280 <  exitcode=1
281 <  echo positional parameters were not saved.
282 < fi
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 < test $exitcode = 0) || { (exit 1); exit 1; }
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 < (
294 <  as_lineno_1=$LINENO
295 <  as_lineno_2=$LINENO
296 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
297 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2") || { (exit 1); exit 1; }
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  
335 – _ASEOF
336 – }; then
337 –  break
338 – fi
332  
333 < 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 <      done
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  
344 –      if test "x$CONFIG_SHELL" != x; then
345 –  for as_var in BASH_ENV ENV
346 –        do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
347 –        done
348 –        export CONFIG_SHELL
349 –        exec "$CONFIG_SHELL" "$as_myself" ${1+"$@"}
350 – 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 <    if test $as_have_required = no; then
387 <  echo This script requires a shell more modern than all the
388 <      echo shells that I found on your system.  Please install a
356 <      echo modern shell, or manually run the script under such a
357 <      echo shell if you do have one.
358 <      { (exit 1); exit 1; }
359 < fi
360 <
361 <
362 < fi
363 <
364 < fi
365 <
366 <
367 <
368 < (eval "as_func_return () {
369 <  (exit \$1)
370 < }
371 < as_func_success () {
372 <  as_func_return 0
373 < }
374 < as_func_failure () {
375 <  as_func_return 1
376 < }
377 < as_func_ret_success () {
378 <  return 0
379 < }
380 < as_func_ret_failure () {
381 <  return 1
382 < }
383 <
384 < exitcode=0
385 < if as_func_success; then
386 <  :
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
389 <  echo as_func_success failed.
390 >  as_expr=false
391   fi
392  
393 < if as_func_failure; then
394 <  exitcode=1
394 <  echo as_func_failure succeeded.
395 < fi
396 <
397 < if as_func_ret_success; then
398 <  :
393 > if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
394 >  as_basename=basename
395   else
396 <  exitcode=1
401 <  echo as_func_ret_success failed.
396 >  as_basename=false
397   fi
398  
399 < if as_func_ret_failure; then
400 <  exitcode=1
406 <  echo as_func_ret_failure succeeded.
407 < fi
408 <
409 < if ( set x; as_func_ret_success y && test x = \"\$1\" ); then
410 <  :
399 > if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
400 >  as_dirname=dirname
401   else
402 <  exitcode=1
413 <  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 autoconf@gnu.org about your system,
408 <  echo including any error possibly output before this
409 <  echo message
410 < }
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 <
430 <  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
431 <  # uniformly replaced by the line number.  The first 'sed' inserts a
432 <  # line-number line after each line using $LINENO; the second 'sed'
433 <  # does the real work.  The second script uses 'N' to pair each
434 <  # line-number line with the line containing $LINENO, and appends
435 <  # trailing '-' during substitution so that $LINENO is not a special
436 <  # case at line end.
437 <  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
438 <  # scripts with optimization help from Paolo Bonzini.  Blame Lee
439 <  # 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 453 | Line 450 | test \$exitcode = 0") || {
450        s/-\n.*//
451      ' >$as_me.lineno &&
452    chmod +x "$as_me.lineno" ||
453 <    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
457 <   { (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 464 | Line 460 | test \$exitcode = 0") || {
460    exit
461   }
462  
467 –
468 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
469 –  as_dirname=dirname
470 – else
471 –  as_dirname=false
472 – fi
473 –
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
475  
485 – if expr a : '\(a\)' >/dev/null 2>&1 &&
486 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
487 –  as_expr=expr
488 – else
489 –  as_expr=false
490 – fi
491 –
476   rm -f conf$$ conf$$.exe conf$$.file
477   if test -d conf$$.dir; then
478    rm -f conf$$.dir/conf$$.file
479   else
480    rm -f conf$$.dir
481 <  mkdir conf$$.dir
481 >  mkdir conf$$.dir 2>/dev/null
482   fi
483 < echo >conf$$.file
484 < if ln -s conf$$.file conf$$ 2>/dev/null; then
485 <  as_ln_s='ln -s'
486 <  # ... but there are two gotchas:
487 <  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
488 <  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
489 <  # In both cases, we have to default to `cp -p'.
490 <  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
483 > if (echo >conf$$.file) 2>/dev/null; then
484 >  if ln -s conf$$.file conf$$ 2>/dev/null; then
485 >    as_ln_s='ln -s'
486 >    # ... but there are two gotchas:
487 >    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
488 >    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
489 >    # In both cases, we have to default to `cp -p'.
490 >    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
491 >      as_ln_s='cp -p'
492 >  elif ln conf$$.file conf$$ 2>/dev/null; then
493 >    as_ln_s=ln
494 >  else
495      as_ln_s='cp -p'
496 < elif ln conf$$.file conf$$ 2>/dev/null; then
509 <  as_ln_s=ln
496 >  fi
497   else
498    as_ln_s='cp -p'
499   fi
# Line 514 | 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 531 | Line 518 | else
518    as_test_x='
519      eval sh -c '\''
520        if test -d "$1"; then
521 <        test -d "$1/.";
521 >        test -d "$1/.";
522        else
523 <        case $1 in
524 <        -*)set "./$1";;
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 550 | 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  
554 – exec 7<&0 </dev/null 6>&1
555 –
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 569 | Line 556 | MAKEFLAGS=
556   subdirs=
557   MFLAGS=
558   MAKEFLAGS=
572 – SHELL=${CONFIG_SHELL-/bin/sh}
559  
560   # Identity of this package.
561 < PACKAGE_NAME='OOPSE'
562 < PACKAGE_TARNAME='oopse'
563 < PACKAGE_VERSION='4.0'
564 < PACKAGE_STRING='OOPSE 4.0'
561 > PACKAGE_NAME='OpenMD'
562 > PACKAGE_TARNAME='openmd'
563 > PACKAGE_VERSION='1.0'
564 > PACKAGE_STRING='OpenMD 1.0'
565   PACKAGE_BUGREPORT='gezelter@nd.edu'
566 + PACKAGE_URL=''
567  
568 < ac_unique_file="src/applications/oopse/oopse.cpp"
568 > ac_unique_file="src/applications/openmd/openmd.cpp"
569   ac_default_prefix="/usr/local"
570   # Factoring default headers for most tests.
571   ac_includes_default="\
# Line 616 | Line 603 | ac_includes_default="\
603   # include <unistd.h>
604   #endif"
605  
606 < ac_subst_vars='SHELL
607 < PATH_SEPARATOR
608 < PACKAGE_NAME
609 < PACKAGE_TARNAME
610 < PACKAGE_VERSION
611 < PACKAGE_STRING
612 < PACKAGE_BUGREPORT
613 < exec_prefix
614 < prefix
615 < program_transform_name
616 < bindir
617 < sbindir
618 < libexecdir
619 < datarootdir
620 < datadir
621 < sysconfdir
622 < sharedstatedir
623 < localstatedir
624 < includedir
625 < oldincludedir
626 < docdir
627 < infodir
628 < htmldir
629 < dvidir
630 < pdfdir
631 < psdir
632 < libdir
633 < localedir
634 < mandir
635 < DEFS
636 < ECHO_C
637 < ECHO_N
638 < ECHO_T
639 < LIBS
640 < build_alias
641 < host_alias
642 < target_alias
643 < build
644 < build_cpu
645 < build_vendor
646 < build_os
647 < host
661 < host_cpu
662 < host_vendor
663 < host_os
664 < PROGNAME
665 < debug
666 < USE_SINGLE_PRECISION
667 < ac_cc_set
668 < ac_cc_path
669 < ac_cxx_set
670 < ac_cxx_path
671 < ac_fc_set
672 < ac_fc_path
673 < acx_mpi_mpicc
674 < acx_mpi_mpicc_path
675 < acx_mpi_mpif90
676 < acx_mpi_mpif90_path
677 < acx_mpi_mpicxx
678 < acx_mpi_mpicxx_path
679 < MPI_CPPFLAGS
680 < MPI_LIBS
681 < MPI90_LIBS
606 > ac_subst_vars='LTLIBOBJS
607 > SUBDIRS
608 > OPENMD_HOME
609 > OPENMD
610 > MKINSTALLDIRS
611 > BATEXT
612 > enable_latex_docs
613 > enable_html_docs
614 > enable_dot
615 > DOC
616 > DOT
617 > DOXYGEN
618 > POW_LIB
619 > LIBOBJS
620 > USE_OPENBABEL
621 > OPENBABEL_LIB
622 > OPENBABEL_LIB_DIR
623 > OPENBABEL_INC_DIR
624 > CXXCPP
625 > USE_QHULL
626 > QHULL
627 > QHULL_LIB_DIR
628 > QHULL_INC_DIR
629 > FFTW_LIBS
630 > FFTW_LIB_DIR
631 > FFTW_INC_DIR
632 > ZLIB
633 > ZLIB_LIB_DIR
634 > ZLIB_INC_DIR
635 > PS
636 > AR
637 > INSTALL_DATA
638 > INSTALL_SCRIPT
639 > INSTALL_PROGRAM
640 > PERL_SHEBANG
641 > PERLINTERP
642 > RANLIB
643 > SET_MAKE
644 > LN_S
645 > EGREP
646 > GREP
647 > CPP
648   USE_MPI
649 < CXX
650 < CXXFLAGS
651 < LDFLAGS
652 < CPPFLAGS
687 < ac_ct_CXX
688 < EXEEXT
689 < OBJEXT
690 < CC
691 < CFLAGS
649 > MPICC
650 > MPILIBS
651 > MPICXX
652 > LIBDL
653   ac_ct_CC
654 < FC
655 < FCFLAGS
656 < ac_ct_FC
657 < CPP
658 < GREP
659 < EGREP
660 < LN_S
661 < SET_MAKE
662 < RANLIB
663 < PERLINTERP
664 < PERL_SHEBANG
665 < INSTALL_PROGRAM
666 < INSTALL_SCRIPT
667 < INSTALL_DATA
668 < AR
669 < PS
670 < FCFLAGS_F90
671 < FCFLAGS_SRCEXT
672 < PREPDEFFLAG
673 < FCLIBS
674 < FC_FUNC
675 < FC_FUNC_
676 < MOD
677 < F90_WORK_FILES_ARG
678 < MODDIRFLAG
679 < F90MODINCSPEC
680 < F90_MODULE_NAMES
681 < ZLIB_INC_DIR
682 < ZLIB_LIB_DIR
683 < ZLIB
684 < FFTW_INC_DIR
685 < FFTW_LIB_DIR
686 < FFTW_LIBS
687 < QHULL_INC_DIR
688 < QHULL_LIB_DIR
689 < QHULL
690 < USE_QHULL
691 < CXXCPP
692 < OPENBABEL_INC_DIR
693 < OPENBABEL_LIB_DIR
694 < OPENBABEL_LIB
695 < USE_OPENBABEL
696 < LIBOBJS
697 < POW_LIB
698 < CGAL_MAKEFILE
699 < CGAL_CXXFLAGS
700 < CGAL_CPPFLAGS
701 < CGAL_LDFLAGS
702 < CGAL_LIBS
703 < USE_CGAL
704 < DOXYGEN
705 < DOT
706 < DOC
654 > CFLAGS
655 > CC
656 > OBJEXT
657 > EXEEXT
658 > ac_ct_CXX
659 > CPPFLAGS
660 > LDFLAGS
661 > CXXFLAGS
662 > CXX
663 > USE_SINGLE_PRECISION
664 > debug
665 > PROGNAME
666 > host_os
667 > host_vendor
668 > host_cpu
669 > host
670 > build_os
671 > build_vendor
672 > build_cpu
673 > build
674 > target_alias
675 > host_alias
676 > build_alias
677 > LIBS
678 > ECHO_T
679 > ECHO_N
680 > ECHO_C
681 > DEFS
682 > mandir
683 > localedir
684 > libdir
685 > psdir
686 > pdfdir
687 > dvidir
688 > htmldir
689 > infodir
690 > docdir
691 > oldincludedir
692 > includedir
693 > localstatedir
694 > sharedstatedir
695 > sysconfdir
696 > datadir
697 > datarootdir
698 > libexecdir
699 > sbindir
700 > bindir
701 > program_transform_name
702 > prefix
703 > exec_prefix
704 > PACKAGE_URL
705 > PACKAGE_BUGREPORT
706 > PACKAGE_STRING
707 > PACKAGE_VERSION
708 > PACKAGE_TARNAME
709 > PACKAGE_NAME
710 > PATH_SEPARATOR
711 > SHELL'
712 > ac_subst_files=''
713 > ac_user_opts='
714 > enable_option_checking
715 > enable_openmd_home
716 > enable_debug
717 > enable_single
718 > enable_float
719 > with_perl_shebang
720 > with_zlib
721 > with_fftw
722 > with_qhull
723 > with_openbabel
724 > enable_doxygen
725   enable_dot
726   enable_html_docs
727   enable_latex_docs
728 < BATEXT
750 < MKINSTALLDIRS
751 < OOPSE
752 < OOPSE_HOME
753 < SUBDIRS
754 < LTLIBOBJS'
755 < ac_subst_files=''
728 > '
729        ac_precious_vars='build_alias
730   host_alias
731   target_alias
# Line 764 | Line 737 | CFLAGS
737   CCC
738   CC
739   CFLAGS
740 < FC
741 < FCFLAGS
740 > MPICXX
741 > MPICC
742   CPP
743   CXXCPP'
744  
# Line 773 | Line 746 | ac_init_version=false
746   # Initialize some variables set by options.
747   ac_init_help=
748   ac_init_version=false
749 + ac_unrecognized_opts=
750 + ac_unrecognized_sep=
751   # The variables have the same names as the options, with
752   # dashes changed to underlines.
753   cache_file=/dev/null
# Line 828 | Line 803 | do
803    fi
804  
805    case $ac_option in
806 <  *=*)  ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
807 <  *)    ac_optarg=yes ;;
806 >  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
807 >  *=)   ac_optarg= ;;
808 >  *)    ac_optarg=yes ;;
809    esac
810  
811    # Accept the important Cygnus configure options, so we can diagnose typos.
# Line 871 | Line 847 | do
847      datarootdir=$ac_optarg ;;
848  
849    -disable-* | --disable-*)
850 <    ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
850 >    ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
851      # Reject names that are not valid shell variable names.
852 <    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
853 <      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
854 <   { (exit 1); exit 1; }; }
855 <    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
856 <    eval enable_$ac_feature=no ;;
852 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
853 >      as_fn_error $? "invalid feature name: $ac_useropt"
854 >    ac_useropt_orig=$ac_useropt
855 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
856 >    case $ac_user_opts in
857 >      *"
858 > "enable_$ac_useropt"
859 > "*) ;;
860 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
861 >         ac_unrecognized_sep=', ';;
862 >    esac
863 >    eval enable_$ac_useropt=no ;;
864  
865    -docdir | --docdir | --docdi | --doc | --do)
866      ac_prev=docdir ;;
# Line 890 | Line 873 | do
873      dvidir=$ac_optarg ;;
874  
875    -enable-* | --enable-*)
876 <    ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
876 >    ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
877      # Reject names that are not valid shell variable names.
878 <    expr "x$ac_feature" : ".*[^-._$as_cr_alnum]" >/dev/null &&
879 <      { echo "$as_me: error: invalid feature name: $ac_feature" >&2
880 <   { (exit 1); exit 1; }; }
881 <    ac_feature=`echo $ac_feature | sed 's/[-.]/_/g'`
882 <    eval enable_$ac_feature=\$ac_optarg ;;
878 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
879 >      as_fn_error $? "invalid feature name: $ac_useropt"
880 >    ac_useropt_orig=$ac_useropt
881 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
882 >    case $ac_user_opts in
883 >      *"
884 > "enable_$ac_useropt"
885 > "*) ;;
886 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
887 >         ac_unrecognized_sep=', ';;
888 >    esac
889 >    eval enable_$ac_useropt=\$ac_optarg ;;
890  
891    -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
892    | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
# Line 1087 | Line 1077 | do
1077      ac_init_version=: ;;
1078  
1079    -with-* | --with-*)
1080 <    ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1080 >    ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
1081      # Reject names that are not valid shell variable names.
1082 <    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1083 <      { echo "$as_me: error: invalid package name: $ac_package" >&2
1084 <   { (exit 1); exit 1; }; }
1085 <    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1086 <    eval with_$ac_package=\$ac_optarg ;;
1082 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1083 >      as_fn_error $? "invalid package name: $ac_useropt"
1084 >    ac_useropt_orig=$ac_useropt
1085 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1086 >    case $ac_user_opts in
1087 >      *"
1088 > "with_$ac_useropt"
1089 > "*) ;;
1090 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
1091 >         ac_unrecognized_sep=', ';;
1092 >    esac
1093 >    eval with_$ac_useropt=\$ac_optarg ;;
1094  
1095    -without-* | --without-*)
1096 <    ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1096 >    ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
1097      # Reject names that are not valid shell variable names.
1098 <    expr "x$ac_package" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1099 <      { echo "$as_me: error: invalid package name: $ac_package" >&2
1100 <   { (exit 1); exit 1; }; }
1101 <    ac_package=`echo $ac_package | sed 's/[-.]/_/g'`
1102 <    eval with_$ac_package=no ;;
1098 >    expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
1099 >      as_fn_error $? "invalid package name: $ac_useropt"
1100 >    ac_useropt_orig=$ac_useropt
1101 >    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
1102 >    case $ac_user_opts in
1103 >      *"
1104 > "with_$ac_useropt"
1105 > "*) ;;
1106 >      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
1107 >         ac_unrecognized_sep=', ';;
1108 >    esac
1109 >    eval with_$ac_useropt=no ;;
1110  
1111    --x)
1112      # Obsolete; use --with-x.
# Line 1122 | Line 1126 | do
1126    | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
1127      x_libraries=$ac_optarg ;;
1128  
1129 <  -*) { echo "$as_me: error: unrecognized option: $ac_option
1130 < Try \`$0 --help' for more information." >&2
1127 <   { (exit 1); exit 1; }; }
1129 >  -*) as_fn_error $? "unrecognized option: \`$ac_option'
1130 > Try \`$0 --help' for more information"
1131      ;;
1132  
1133    *=*)
1134      ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
1135      # Reject names that are not valid shell variable names.
1136 <    expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
1137 <      { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
1138 <   { (exit 1); exit 1; }; }
1136 >    case $ac_envvar in #(
1137 >      '' | [0-9]* | *[!_$as_cr_alnum]* )
1138 >      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
1139 >    esac
1140      eval $ac_envvar=\$ac_optarg
1141      export $ac_envvar ;;
1142  
1143    *)
1144      # FIXME: should be removed in autoconf 3.0.
1145 <    echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1145 >    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
1146      expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
1147 <      echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1148 <    : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
1147 >      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
1148 >    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
1149      ;;
1150  
1151    esac
# Line 1149 | Line 1153 | if test -n "$ac_prev"; then
1153  
1154   if test -n "$ac_prev"; then
1155    ac_option=--`echo $ac_prev | sed 's/_/-/g'`
1156 <  { echo "$as_me: error: missing argument to $ac_option" >&2
1153 <   { (exit 1); exit 1; }; }
1156 >  as_fn_error $? "missing argument to $ac_option"
1157   fi
1158  
1159 < # Be sure to have absolute directory names.
1159 > if test -n "$ac_unrecognized_opts"; then
1160 >  case $enable_option_checking in
1161 >    no) ;;
1162 >    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
1163 >    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
1164 >  esac
1165 > fi
1166 >
1167 > # Check all directory arguments for consistency.
1168   for ac_var in   exec_prefix prefix bindir sbindir libexecdir datarootdir \
1169                  datadir sysconfdir sharedstatedir localstatedir includedir \
1170                  oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
1171                  libdir localedir mandir
1172   do
1173    eval ac_val=\$$ac_var
1174 +  # Remove trailing slashes.
1175    case $ac_val in
1176 +    */ )
1177 +      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
1178 +      eval $ac_var=\$ac_val;;
1179 +  esac
1180 +  # Be sure to have absolute directory names.
1181 +  case $ac_val in
1182      [\\/$]* | ?:[\\/]* )  continue;;
1183      NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
1184    esac
1185 <  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
1168 <   { (exit 1); exit 1; }; }
1185 >  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
1186   done
1187  
1188   # There might be people who depend on the old broken behavior: `$host'
# Line 1179 | Line 1196 | if test "x$host_alias" != x; then
1196   if test "x$host_alias" != x; then
1197    if test "x$build_alias" = x; then
1198      cross_compiling=maybe
1199 <    echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
1200 <    If a cross compiler is detected then cross compile mode will be used." >&2
1199 >    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
1200 >    If a cross compiler is detected then cross compile mode will be used" >&2
1201    elif test "x$build_alias" != "x$host_alias"; then
1202      cross_compiling=yes
1203    fi
# Line 1195 | Line 1212 | ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1212   ac_pwd=`pwd` && test -n "$ac_pwd" &&
1213   ac_ls_di=`ls -di .` &&
1214   ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
1215 <  { echo "$as_me: error: Working directory cannot be determined" >&2
1199 <   { (exit 1); exit 1; }; }
1215 >  as_fn_error $? "working directory cannot be determined"
1216   test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
1217 <  { echo "$as_me: error: pwd does not report name of working directory" >&2
1202 <   { (exit 1); exit 1; }; }
1217 >  as_fn_error $? "pwd does not report name of working directory"
1218  
1219  
1220   # Find the source files, if location was not specified.
1221   if test -z "$srcdir"; then
1222    ac_srcdir_defaulted=yes
1223    # Try the directory containing this script, then the parent directory.
1224 <  ac_confdir=`$as_dirname -- "$0" ||
1225 < $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1226 <         X"$0" : 'X\(//\)[^/]' \| \
1227 <         X"$0" : 'X\(//\)$' \| \
1228 <         X"$0" : 'X\(/\)' \| . 2>/dev/null ||
1229 < echo X"$0" |
1224 >  ac_confdir=`$as_dirname -- "$as_myself" ||
1225 > $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
1226 >         X"$as_myself" : 'X\(//\)[^/]' \| \
1227 >         X"$as_myself" : 'X\(//\)$' \| \
1228 >         X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
1229 > $as_echo X"$as_myself" |
1230      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
1231              s//\1/
1232              q
# Line 1238 | Line 1253 | if test ! -r "$srcdir/$ac_unique_file"; then
1253   fi
1254   if test ! -r "$srcdir/$ac_unique_file"; then
1255    test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
1256 <  { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
1242 <   { (exit 1); exit 1; }; }
1256 >  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
1257   fi
1258   ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
1259   ac_abs_confdir=`(
1260 <        cd "$srcdir" && test -r "./$ac_unique_file" || { echo "$as_me: error: $ac_msg" >&2
1247 <   { (exit 1); exit 1; }; }
1260 >        cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
1261          pwd)`
1262   # When building in place, set srcdir=.
1263   if test "$ac_abs_confdir" = "$ac_pwd"; then
# Line 1270 | Line 1283 | if test "$ac_init_help" = "long"; then
1283    # Omit some internal or obsolete options to make the list less imposing.
1284    # This message is too long to be a string in the A/UX 3.1 sh.
1285    cat <<_ACEOF
1286 < \`configure' configures OOPSE 4.0 to adapt to many kinds of systems.
1286 > \`configure' configures OpenMD 1.0 to adapt to many kinds of systems.
1287  
1288   Usage: $0 [OPTION]... [VAR=VALUE]...
1289  
# Line 1284 | Line 1297 | Configuration:
1297        --help=short        display options specific to this package
1298        --help=recursive    display the short help of all the included packages
1299    -V, --version           display version information and exit
1300 <  -q, --quiet, --silent   do not print \`checking...' messages
1300 >  -q, --quiet, --silent   do not print \`checking ...' messages
1301        --cache-file=FILE   cache test results in FILE [disabled]
1302    -C, --config-cache      alias for \`--cache-file=config.cache'
1303    -n, --no-create         do not create output files
# Line 1292 | Line 1305 | Installation directories:
1305  
1306   Installation directories:
1307    --prefix=PREFIX         install architecture-independent files in PREFIX
1308 <                          [$ac_default_prefix]
1308 >                          [$ac_default_prefix]
1309    --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
1310 <                          [PREFIX]
1310 >                          [PREFIX]
1311  
1312   By default, \`make install' will install all the files in
1313   \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
# Line 1304 | Line 1317 | Fine tuning of the installation directories:
1317   For better control, use the options below.
1318  
1319   Fine tuning of the installation directories:
1320 <  --bindir=DIR           user executables [EPREFIX/bin]
1321 <  --sbindir=DIR          system admin executables [EPREFIX/sbin]
1322 <  --libexecdir=DIR       program executables [EPREFIX/libexec]
1323 <  --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
1324 <  --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
1325 <  --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
1326 <  --libdir=DIR           object code libraries [EPREFIX/lib]
1327 <  --includedir=DIR       C header files [PREFIX/include]
1328 <  --oldincludedir=DIR    C header files for non-gcc [/usr/include]
1329 <  --datarootdir=DIR      read-only arch.-independent data root [PREFIX/share]
1330 <  --datadir=DIR          read-only architecture-independent data [DATAROOTDIR]
1331 <  --infodir=DIR          info documentation [DATAROOTDIR/info]
1332 <  --localedir=DIR        locale-dependent data [DATAROOTDIR/locale]
1333 <  --mandir=DIR           man documentation [DATAROOTDIR/man]
1334 <  --docdir=DIR           documentation root [DATAROOTDIR/doc/oopse]
1335 <  --htmldir=DIR          html documentation [DOCDIR]
1336 <  --dvidir=DIR           dvi documentation [DOCDIR]
1337 <  --pdfdir=DIR           pdf documentation [DOCDIR]
1338 <  --psdir=DIR            ps documentation [DOCDIR]
1320 >  --bindir=DIR            user executables [EPREFIX/bin]
1321 >  --sbindir=DIR           system admin executables [EPREFIX/sbin]
1322 >  --libexecdir=DIR        program executables [EPREFIX/libexec]
1323 >  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
1324 >  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
1325 >  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
1326 >  --libdir=DIR            object code libraries [EPREFIX/lib]
1327 >  --includedir=DIR        C header files [PREFIX/include]
1328 >  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
1329 >  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
1330 >  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
1331 >  --infodir=DIR           info documentation [DATAROOTDIR/info]
1332 >  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]
1333 >  --mandir=DIR            man documentation [DATAROOTDIR/man]
1334 >  --docdir=DIR            documentation root [DATAROOTDIR/doc/openmd]
1335 >  --htmldir=DIR           html documentation [DOCDIR]
1336 >  --dvidir=DIR            dvi documentation [DOCDIR]
1337 >  --pdfdir=DIR            pdf documentation [DOCDIR]
1338 >  --psdir=DIR             ps documentation [DOCDIR]
1339   _ACEOF
1340  
1341    cat <<\_ACEOF
# Line 1335 | Line 1348 | if test -n "$ac_init_help"; then
1348  
1349   if test -n "$ac_init_help"; then
1350    case $ac_init_help in
1351 <     short | recursive ) echo "Configuration of OOPSE 4.0:";;
1351 >     short | recursive ) echo "Configuration of OpenMD 1.0:";;
1352     esac
1353    cat <<\_ACEOF
1354  
1355   Optional Features:
1356 +  --disable-option-checking  ignore unrecognized --enable/--with options
1357    --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
1358    --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
1359 <  --enable-oopse-home=DIR      define oopse home dir PREFIX/oopse
1360 <  --enable-debug          Compile OOPSE in debug mode
1361 <  --enable-single         compile OOPSE in single precision
1359 >  --enable-openmd-home=DIR      define OpenMD home dir PREFIX/openmd
1360 >  --enable-debug          Compile OpenMD in debug mode
1361 >  --enable-single         compile OpenMD in single precision
1362    --enable-float          synonym for --enable-single
1363    --enable-doxygen        enable documentation generation with doxygen (auto)
1364    --enable-dot            use 'dot' to generate graphs in doxygen (auto)
# Line 1354 | Line 1368 | Optional Packages:
1368   Optional Packages:
1369    --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
1370    --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
1357 –  --with-mpi=auto|mpich|lam|openmpi|no
1358 –                          Indicates which kind of MPI implementation to use
1359 –                          [default=auto]
1371    --with-perl-shebang     override what perl thinks is the way for the kernel
1372                            to start it (seldom needed)
1373    --with-zlib=DIR         root directory path of zlib installation (defaults
# Line 1368 | Line 1379 | Optional Packages:
1379    --with-openbabel=DIR    root directory path of openbabel-2.x installation
1380                            (defaults to /usr/local or /usr if not found in
1381                            /usr/local)
1371 –  --with-cgalmakefile=makefile
1372 –                          Use the following CGAL makefile
1382  
1383   Some influential environment variables:
1384    CXX         C++ compiler command
# Line 1377 | Line 1386 | Some influential environment variables:
1386    LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1387                nonstandard directory <lib dir>
1388    LIBS        libraries to pass to the linker, e.g. -l<library>
1389 <  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1389 >  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
1390                you have headers in a nonstandard directory <include dir>
1391    CC          C compiler command
1392    CFLAGS      C compiler flags
1393 <  FC          Fortran compiler command
1394 <  FCFLAGS     Fortran compiler flags
1393 >  MPICXX      MPI C++ compiler command
1394 >  MPICC       MPI C compiler command
1395    CPP         C preprocessor
1396    CXXCPP      C++ preprocessor
1397  
# Line 1397 | Line 1406 | if test "$ac_init_help" = "recursive"; then
1406   if test "$ac_init_help" = "recursive"; then
1407    # If there are subdirs, report their specific --help.
1408    for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1409 <    test -d "$ac_dir" || continue
1409 >    test -d "$ac_dir" ||
1410 >      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
1411 >      continue
1412      ac_builddir=.
1413  
1414   case "$ac_dir" in
1415   .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
1416   *)
1417 <  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1417 >  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
1418    # A ".." for each directory in $ac_dir_suffix.
1419 <  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
1419 >  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
1420    case $ac_top_builddir_sub in
1421    "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
1422    *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
# Line 1441 | Line 1452 | ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
1452        echo &&
1453        $SHELL "$ac_srcdir/configure" --help=recursive
1454      else
1455 <      echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1455 >      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1456      fi || ac_status=$?
1457      cd "$ac_pwd" || { ac_status=$?; break; }
1458    done
# Line 1450 | Line 1461 | if $ac_init_version; then
1461   test -n "$ac_init_help" && exit $ac_status
1462   if $ac_init_version; then
1463    cat <<\_ACEOF
1464 < OOPSE configure 4.0
1465 < generated by GNU Autoconf 2.61
1464 > OpenMD configure 1.0
1465 > generated by GNU Autoconf 2.68
1466  
1467 < Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1457 < 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
1467 > Copyright (C) 2010 Free Software Foundation, Inc.
1468   This configure script is free software; the Free Software Foundation
1469   gives unlimited permission to copy, distribute and modify it.
1470   _ACEOF
1471    exit
1472   fi
1473 +
1474 + ## ------------------------ ##
1475 + ## Autoconf initialization. ##
1476 + ## ------------------------ ##
1477 +
1478 + # ac_fn_cxx_try_compile LINENO
1479 + # ----------------------------
1480 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1481 + ac_fn_cxx_try_compile ()
1482 + {
1483 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1484 +  rm -f conftest.$ac_objext
1485 +  if { { ac_try="$ac_compile"
1486 + case "(($ac_try" in
1487 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1488 +  *) ac_try_echo=$ac_try;;
1489 + esac
1490 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1491 + $as_echo "$ac_try_echo"; } >&5
1492 +  (eval "$ac_compile") 2>conftest.err
1493 +  ac_status=$?
1494 +  if test -s conftest.err; then
1495 +    grep -v '^ *+' conftest.err >conftest.er1
1496 +    cat conftest.er1 >&5
1497 +    mv -f conftest.er1 conftest.err
1498 +  fi
1499 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1500 +  test $ac_status = 0; } && {
1501 +         test -z "$ac_cxx_werror_flag" ||
1502 +         test ! -s conftest.err
1503 +       } && test -s conftest.$ac_objext; then :
1504 +  ac_retval=0
1505 + else
1506 +  $as_echo "$as_me: failed program was:" >&5
1507 + sed 's/^/| /' conftest.$ac_ext >&5
1508 +
1509 +        ac_retval=1
1510 + fi
1511 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1512 +  as_fn_set_status $ac_retval
1513 +
1514 + } # ac_fn_cxx_try_compile
1515 +
1516 + # ac_fn_c_try_compile LINENO
1517 + # --------------------------
1518 + # Try to compile conftest.$ac_ext, and return whether this succeeded.
1519 + ac_fn_c_try_compile ()
1520 + {
1521 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1522 +  rm -f conftest.$ac_objext
1523 +  if { { ac_try="$ac_compile"
1524 + case "(($ac_try" in
1525 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1526 +  *) ac_try_echo=$ac_try;;
1527 + esac
1528 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1529 + $as_echo "$ac_try_echo"; } >&5
1530 +  (eval "$ac_compile") 2>conftest.err
1531 +  ac_status=$?
1532 +  if test -s conftest.err; then
1533 +    grep -v '^ *+' conftest.err >conftest.er1
1534 +    cat conftest.er1 >&5
1535 +    mv -f conftest.er1 conftest.err
1536 +  fi
1537 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1538 +  test $ac_status = 0; } && {
1539 +         test -z "$ac_c_werror_flag" ||
1540 +         test ! -s conftest.err
1541 +       } && test -s conftest.$ac_objext; then :
1542 +  ac_retval=0
1543 + else
1544 +  $as_echo "$as_me: failed program was:" >&5
1545 + sed 's/^/| /' conftest.$ac_ext >&5
1546 +
1547 +        ac_retval=1
1548 + fi
1549 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1550 +  as_fn_set_status $ac_retval
1551 +
1552 + } # ac_fn_c_try_compile
1553 +
1554 + # ac_fn_cxx_try_link LINENO
1555 + # -------------------------
1556 + # Try to link conftest.$ac_ext, and return whether this succeeded.
1557 + ac_fn_cxx_try_link ()
1558 + {
1559 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1560 +  rm -f conftest.$ac_objext conftest$ac_exeext
1561 +  if { { ac_try="$ac_link"
1562 + case "(($ac_try" in
1563 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1564 +  *) ac_try_echo=$ac_try;;
1565 + esac
1566 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1567 + $as_echo "$ac_try_echo"; } >&5
1568 +  (eval "$ac_link") 2>conftest.err
1569 +  ac_status=$?
1570 +  if test -s conftest.err; then
1571 +    grep -v '^ *+' conftest.err >conftest.er1
1572 +    cat conftest.er1 >&5
1573 +    mv -f conftest.er1 conftest.err
1574 +  fi
1575 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1576 +  test $ac_status = 0; } && {
1577 +         test -z "$ac_cxx_werror_flag" ||
1578 +         test ! -s conftest.err
1579 +       } && test -s conftest$ac_exeext && {
1580 +         test "$cross_compiling" = yes ||
1581 +         $as_test_x conftest$ac_exeext
1582 +       }; then :
1583 +  ac_retval=0
1584 + else
1585 +  $as_echo "$as_me: failed program was:" >&5
1586 + sed 's/^/| /' conftest.$ac_ext >&5
1587 +
1588 +        ac_retval=1
1589 + fi
1590 +  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1591 +  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1592 +  # interfere with the next link command; also delete a directory that is
1593 +  # left behind by Apple's compiler.  We do this before executing the actions.
1594 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1595 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1596 +  as_fn_set_status $ac_retval
1597 +
1598 + } # ac_fn_cxx_try_link
1599 +
1600 + # ac_fn_cxx_check_func LINENO FUNC VAR
1601 + # ------------------------------------
1602 + # Tests whether FUNC exists, setting the cache variable VAR accordingly
1603 + ac_fn_cxx_check_func ()
1604 + {
1605 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1606 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1607 + $as_echo_n "checking for $2... " >&6; }
1608 + if eval \${$3+:} false; then :
1609 +  $as_echo_n "(cached) " >&6
1610 + else
1611 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1612 + /* end confdefs.h.  */
1613 + /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1614 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1615 + #define $2 innocuous_$2
1616 +
1617 + /* System header to define __stub macros and hopefully few prototypes,
1618 +    which can conflict with char $2 (); below.
1619 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1620 +    <limits.h> exists even on freestanding compilers.  */
1621 +
1622 + #ifdef __STDC__
1623 + # include <limits.h>
1624 + #else
1625 + # include <assert.h>
1626 + #endif
1627 +
1628 + #undef $2
1629 +
1630 + /* Override any GCC internal prototype to avoid an error.
1631 +   Use char because int might match the return type of a GCC
1632 +   builtin and then its argument prototype would still apply.  */
1633 + #ifdef __cplusplus
1634 + extern "C"
1635 + #endif
1636 + char $2 ();
1637 + /* The GNU C library defines this for functions which it implements
1638 +    to always fail with ENOSYS.  Some functions are actually named
1639 +    something starting with __ and the normal name is an alias.  */
1640 + #if defined __stub_$2 || defined __stub___$2
1641 + choke me
1642 + #endif
1643 +
1644 + int
1645 + main ()
1646 + {
1647 + return $2 ();
1648 +  ;
1649 +  return 0;
1650 + }
1651 + _ACEOF
1652 + if ac_fn_cxx_try_link "$LINENO"; then :
1653 +  eval "$3=yes"
1654 + else
1655 +  eval "$3=no"
1656 + fi
1657 + rm -f core conftest.err conftest.$ac_objext \
1658 +    conftest$ac_exeext conftest.$ac_ext
1659 + fi
1660 + eval ac_res=\$$3
1661 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1662 + $as_echo "$ac_res" >&6; }
1663 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1664 +
1665 + } # ac_fn_cxx_check_func
1666 +
1667 + # ac_fn_c_try_link LINENO
1668 + # -----------------------
1669 + # Try to link conftest.$ac_ext, and return whether this succeeded.
1670 + ac_fn_c_try_link ()
1671 + {
1672 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1673 +  rm -f conftest.$ac_objext conftest$ac_exeext
1674 +  if { { ac_try="$ac_link"
1675 + case "(($ac_try" in
1676 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1677 +  *) ac_try_echo=$ac_try;;
1678 + esac
1679 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1680 + $as_echo "$ac_try_echo"; } >&5
1681 +  (eval "$ac_link") 2>conftest.err
1682 +  ac_status=$?
1683 +  if test -s conftest.err; then
1684 +    grep -v '^ *+' conftest.err >conftest.er1
1685 +    cat conftest.er1 >&5
1686 +    mv -f conftest.er1 conftest.err
1687 +  fi
1688 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1689 +  test $ac_status = 0; } && {
1690 +         test -z "$ac_c_werror_flag" ||
1691 +         test ! -s conftest.err
1692 +       } && test -s conftest$ac_exeext && {
1693 +         test "$cross_compiling" = yes ||
1694 +         $as_test_x conftest$ac_exeext
1695 +       }; then :
1696 +  ac_retval=0
1697 + else
1698 +  $as_echo "$as_me: failed program was:" >&5
1699 + sed 's/^/| /' conftest.$ac_ext >&5
1700 +
1701 +        ac_retval=1
1702 + fi
1703 +  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
1704 +  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
1705 +  # interfere with the next link command; also delete a directory that is
1706 +  # left behind by Apple's compiler.  We do this before executing the actions.
1707 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1708 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1709 +  as_fn_set_status $ac_retval
1710 +
1711 + } # ac_fn_c_try_link
1712 +
1713 + # ac_fn_c_check_func LINENO FUNC VAR
1714 + # ----------------------------------
1715 + # Tests whether FUNC exists, setting the cache variable VAR accordingly
1716 + ac_fn_c_check_func ()
1717 + {
1718 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1719 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1720 + $as_echo_n "checking for $2... " >&6; }
1721 + if eval \${$3+:} false; then :
1722 +  $as_echo_n "(cached) " >&6
1723 + else
1724 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1725 + /* end confdefs.h.  */
1726 + /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
1727 +   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
1728 + #define $2 innocuous_$2
1729 +
1730 + /* System header to define __stub macros and hopefully few prototypes,
1731 +    which can conflict with char $2 (); below.
1732 +    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
1733 +    <limits.h> exists even on freestanding compilers.  */
1734 +
1735 + #ifdef __STDC__
1736 + # include <limits.h>
1737 + #else
1738 + # include <assert.h>
1739 + #endif
1740 +
1741 + #undef $2
1742 +
1743 + /* Override any GCC internal prototype to avoid an error.
1744 +   Use char because int might match the return type of a GCC
1745 +   builtin and then its argument prototype would still apply.  */
1746 + #ifdef __cplusplus
1747 + extern "C"
1748 + #endif
1749 + char $2 ();
1750 + /* The GNU C library defines this for functions which it implements
1751 +    to always fail with ENOSYS.  Some functions are actually named
1752 +    something starting with __ and the normal name is an alias.  */
1753 + #if defined __stub_$2 || defined __stub___$2
1754 + choke me
1755 + #endif
1756 +
1757 + int
1758 + main ()
1759 + {
1760 + return $2 ();
1761 +  ;
1762 +  return 0;
1763 + }
1764 + _ACEOF
1765 + if ac_fn_c_try_link "$LINENO"; then :
1766 +  eval "$3=yes"
1767 + else
1768 +  eval "$3=no"
1769 + fi
1770 + rm -f core conftest.err conftest.$ac_objext \
1771 +    conftest$ac_exeext conftest.$ac_ext
1772 + fi
1773 + eval ac_res=\$$3
1774 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1775 + $as_echo "$ac_res" >&6; }
1776 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1777 +
1778 + } # ac_fn_c_check_func
1779 +
1780 + # ac_fn_c_try_cpp LINENO
1781 + # ----------------------
1782 + # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1783 + ac_fn_c_try_cpp ()
1784 + {
1785 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1786 +  if { { ac_try="$ac_cpp conftest.$ac_ext"
1787 + case "(($ac_try" in
1788 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1789 +  *) ac_try_echo=$ac_try;;
1790 + esac
1791 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1792 + $as_echo "$ac_try_echo"; } >&5
1793 +  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1794 +  ac_status=$?
1795 +  if test -s conftest.err; then
1796 +    grep -v '^ *+' conftest.err >conftest.er1
1797 +    cat conftest.er1 >&5
1798 +    mv -f conftest.er1 conftest.err
1799 +  fi
1800 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1801 +  test $ac_status = 0; } > conftest.i && {
1802 +         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
1803 +         test ! -s conftest.err
1804 +       }; then :
1805 +  ac_retval=0
1806 + else
1807 +  $as_echo "$as_me: failed program was:" >&5
1808 + sed 's/^/| /' conftest.$ac_ext >&5
1809 +
1810 +    ac_retval=1
1811 + fi
1812 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1813 +  as_fn_set_status $ac_retval
1814 +
1815 + } # ac_fn_c_try_cpp
1816 +
1817 + # ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
1818 + # -------------------------------------------------------
1819 + # Tests whether HEADER exists, giving a warning if it cannot be compiled using
1820 + # the include files in INCLUDES and setting the cache variable VAR
1821 + # accordingly.
1822 + ac_fn_c_check_header_mongrel ()
1823 + {
1824 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1825 +  if eval \${$3+:} false; then :
1826 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1827 + $as_echo_n "checking for $2... " >&6; }
1828 + if eval \${$3+:} false; then :
1829 +  $as_echo_n "(cached) " >&6
1830 + fi
1831 + eval ac_res=\$$3
1832 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1833 + $as_echo "$ac_res" >&6; }
1834 + else
1835 +  # Is the header compilable?
1836 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
1837 + $as_echo_n "checking $2 usability... " >&6; }
1838 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1839 + /* end confdefs.h.  */
1840 + $4
1841 + #include <$2>
1842 + _ACEOF
1843 + if ac_fn_c_try_compile "$LINENO"; then :
1844 +  ac_header_compiler=yes
1845 + else
1846 +  ac_header_compiler=no
1847 + fi
1848 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1849 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
1850 + $as_echo "$ac_header_compiler" >&6; }
1851 +
1852 + # Is the header present?
1853 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
1854 + $as_echo_n "checking $2 presence... " >&6; }
1855 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1856 + /* end confdefs.h.  */
1857 + #include <$2>
1858 + _ACEOF
1859 + if ac_fn_c_try_cpp "$LINENO"; then :
1860 +  ac_header_preproc=yes
1861 + else
1862 +  ac_header_preproc=no
1863 + fi
1864 + rm -f conftest.err conftest.i conftest.$ac_ext
1865 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
1866 + $as_echo "$ac_header_preproc" >&6; }
1867 +
1868 + # So?  What about this header?
1869 + case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
1870 +  yes:no: )
1871 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
1872 + $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
1873 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1874 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1875 +    ;;
1876 +  no:yes:* )
1877 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
1878 + $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
1879 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
1880 + $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
1881 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
1882 + $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
1883 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
1884 + $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
1885 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
1886 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
1887 + ( $as_echo "## ------------------------------ ##
1888 + ## Report this to gezelter@nd.edu ##
1889 + ## ------------------------------ ##"
1890 +     ) | sed "s/^/$as_me: WARNING:     /" >&2
1891 +    ;;
1892 + esac
1893 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1894 + $as_echo_n "checking for $2... " >&6; }
1895 + if eval \${$3+:} false; then :
1896 +  $as_echo_n "(cached) " >&6
1897 + else
1898 +  eval "$3=\$ac_header_compiler"
1899 + fi
1900 + eval ac_res=\$$3
1901 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1902 + $as_echo "$ac_res" >&6; }
1903 + fi
1904 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1905 +
1906 + } # ac_fn_c_check_header_mongrel
1907 +
1908 + # ac_fn_c_try_run LINENO
1909 + # ----------------------
1910 + # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
1911 + # that executables *can* be run.
1912 + ac_fn_c_try_run ()
1913 + {
1914 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1915 +  if { { ac_try="$ac_link"
1916 + case "(($ac_try" in
1917 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1918 +  *) ac_try_echo=$ac_try;;
1919 + esac
1920 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1921 + $as_echo "$ac_try_echo"; } >&5
1922 +  (eval "$ac_link") 2>&5
1923 +  ac_status=$?
1924 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1925 +  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
1926 +  { { case "(($ac_try" in
1927 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1928 +  *) ac_try_echo=$ac_try;;
1929 + esac
1930 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1931 + $as_echo "$ac_try_echo"; } >&5
1932 +  (eval "$ac_try") 2>&5
1933 +  ac_status=$?
1934 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
1935 +  test $ac_status = 0; }; }; then :
1936 +  ac_retval=0
1937 + else
1938 +  $as_echo "$as_me: program exited with status $ac_status" >&5
1939 +       $as_echo "$as_me: failed program was:" >&5
1940 + sed 's/^/| /' conftest.$ac_ext >&5
1941 +
1942 +       ac_retval=$ac_status
1943 + fi
1944 +  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
1945 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1946 +  as_fn_set_status $ac_retval
1947 +
1948 + } # ac_fn_c_try_run
1949 +
1950 + # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
1951 + # -------------------------------------------------------
1952 + # Tests whether HEADER exists and can be compiled using the include files in
1953 + # INCLUDES, setting the cache variable VAR accordingly.
1954 + ac_fn_c_check_header_compile ()
1955 + {
1956 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1957 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
1958 + $as_echo_n "checking for $2... " >&6; }
1959 + if eval \${$3+:} false; then :
1960 +  $as_echo_n "(cached) " >&6
1961 + else
1962 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
1963 + /* end confdefs.h.  */
1964 + $4
1965 + #include <$2>
1966 + _ACEOF
1967 + if ac_fn_c_try_compile "$LINENO"; then :
1968 +  eval "$3=yes"
1969 + else
1970 +  eval "$3=no"
1971 + fi
1972 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
1973 + fi
1974 + eval ac_res=\$$3
1975 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
1976 + $as_echo "$ac_res" >&6; }
1977 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
1978 +
1979 + } # ac_fn_c_check_header_compile
1980 +
1981 + # ac_fn_cxx_try_cpp LINENO
1982 + # ------------------------
1983 + # Try to preprocess conftest.$ac_ext, and return whether this succeeded.
1984 + ac_fn_cxx_try_cpp ()
1985 + {
1986 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
1987 +  if { { ac_try="$ac_cpp conftest.$ac_ext"
1988 + case "(($ac_try" in
1989 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
1990 +  *) ac_try_echo=$ac_try;;
1991 + esac
1992 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
1993 + $as_echo "$ac_try_echo"; } >&5
1994 +  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
1995 +  ac_status=$?
1996 +  if test -s conftest.err; then
1997 +    grep -v '^ *+' conftest.err >conftest.er1
1998 +    cat conftest.er1 >&5
1999 +    mv -f conftest.er1 conftest.err
2000 +  fi
2001 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
2002 +  test $ac_status = 0; } > conftest.i && {
2003 +         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
2004 +         test ! -s conftest.err
2005 +       }; then :
2006 +  ac_retval=0
2007 + else
2008 +  $as_echo "$as_me: failed program was:" >&5
2009 + sed 's/^/| /' conftest.$ac_ext >&5
2010 +
2011 +    ac_retval=1
2012 + fi
2013 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2014 +  as_fn_set_status $ac_retval
2015 +
2016 + } # ac_fn_cxx_try_cpp
2017 +
2018 + # ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
2019 + # ---------------------------------------------------------
2020 + # Tests whether HEADER exists, giving a warning if it cannot be compiled using
2021 + # the include files in INCLUDES and setting the cache variable VAR
2022 + # accordingly.
2023 + ac_fn_cxx_check_header_mongrel ()
2024 + {
2025 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2026 +  if eval \${$3+:} false; then :
2027 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2028 + $as_echo_n "checking for $2... " >&6; }
2029 + if eval \${$3+:} false; then :
2030 +  $as_echo_n "(cached) " >&6
2031 + fi
2032 + eval ac_res=\$$3
2033 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2034 + $as_echo "$ac_res" >&6; }
2035 + else
2036 +  # Is the header compilable?
2037 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
2038 + $as_echo_n "checking $2 usability... " >&6; }
2039 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2040 + /* end confdefs.h.  */
2041 + $4
2042 + #include <$2>
2043 + _ACEOF
2044 + if ac_fn_cxx_try_compile "$LINENO"; then :
2045 +  ac_header_compiler=yes
2046 + else
2047 +  ac_header_compiler=no
2048 + fi
2049 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2050 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
2051 + $as_echo "$ac_header_compiler" >&6; }
2052 +
2053 + # Is the header present?
2054 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
2055 + $as_echo_n "checking $2 presence... " >&6; }
2056 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2057 + /* end confdefs.h.  */
2058 + #include <$2>
2059 + _ACEOF
2060 + if ac_fn_cxx_try_cpp "$LINENO"; then :
2061 +  ac_header_preproc=yes
2062 + else
2063 +  ac_header_preproc=no
2064 + fi
2065 + rm -f conftest.err conftest.i conftest.$ac_ext
2066 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
2067 + $as_echo "$ac_header_preproc" >&6; }
2068 +
2069 + # So?  What about this header?
2070 + case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
2071 +  yes:no: )
2072 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
2073 + $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
2074 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2075 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2076 +    ;;
2077 +  no:yes:* )
2078 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
2079 + $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
2080 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
2081 + $as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
2082 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
2083 + $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
2084 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
2085 + $as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
2086 +    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
2087 + $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
2088 + ( $as_echo "## ------------------------------ ##
2089 + ## Report this to gezelter@nd.edu ##
2090 + ## ------------------------------ ##"
2091 +     ) | sed "s/^/$as_me: WARNING:     /" >&2
2092 +    ;;
2093 + esac
2094 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2095 + $as_echo_n "checking for $2... " >&6; }
2096 + if eval \${$3+:} false; then :
2097 +  $as_echo_n "(cached) " >&6
2098 + else
2099 +  eval "$3=\$ac_header_compiler"
2100 + fi
2101 + eval ac_res=\$$3
2102 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2103 + $as_echo "$ac_res" >&6; }
2104 + fi
2105 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2106 +
2107 + } # ac_fn_cxx_check_header_mongrel
2108 +
2109 + # ac_fn_c_check_type LINENO TYPE VAR INCLUDES
2110 + # -------------------------------------------
2111 + # Tests whether TYPE exists after having included INCLUDES, setting cache
2112 + # variable VAR accordingly.
2113 + ac_fn_c_check_type ()
2114 + {
2115 +  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
2116 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
2117 + $as_echo_n "checking for $2... " >&6; }
2118 + if eval \${$3+:} false; then :
2119 +  $as_echo_n "(cached) " >&6
2120 + else
2121 +  eval "$3=no"
2122 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2123 + /* end confdefs.h.  */
2124 + $4
2125 + int
2126 + main ()
2127 + {
2128 + if (sizeof ($2))
2129 +         return 0;
2130 +  ;
2131 +  return 0;
2132 + }
2133 + _ACEOF
2134 + if ac_fn_c_try_compile "$LINENO"; then :
2135 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
2136 + /* end confdefs.h.  */
2137 + $4
2138 + int
2139 + main ()
2140 + {
2141 + if (sizeof (($2)))
2142 +            return 0;
2143 +  ;
2144 +  return 0;
2145 + }
2146 + _ACEOF
2147 + if ac_fn_c_try_compile "$LINENO"; then :
2148 +
2149 + else
2150 +  eval "$3=yes"
2151 + fi
2152 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2153 + fi
2154 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2155 + fi
2156 + eval ac_res=\$$3
2157 +               { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
2158 + $as_echo "$ac_res" >&6; }
2159 +  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
2160 +
2161 + } # ac_fn_c_check_type
2162   cat >config.log <<_ACEOF
2163   This file contains any messages produced by compilers while
2164   running configure, to aid debugging if configure makes a mistake.
2165  
2166 < It was created by OOPSE $as_me 4.0, which was
2167 < generated by GNU Autoconf 2.61.  Invocation command line was
2166 > It was created by OpenMD $as_me 1.0, which was
2167 > generated by GNU Autoconf 2.68.  Invocation command line was
2168  
2169    $ $0 $@
2170  
# Line 1501 | Line 2200 | do
2200   do
2201    IFS=$as_save_IFS
2202    test -z "$as_dir" && as_dir=.
2203 <  echo "PATH: $as_dir"
2204 < done
2203 >    $as_echo "PATH: $as_dir"
2204 >  done
2205   IFS=$as_save_IFS
2206  
2207   } >&5
# Line 1536 | Line 2235 | do
2235      | -silent | --silent | --silen | --sile | --sil)
2236        continue ;;
2237      *\'*)
2238 <      ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2238 >      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
2239      esac
2240      case $ac_pass in
2241 <    1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
2241 >    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
2242      2)
2243 <      ac_configure_args1="$ac_configure_args1 '$ac_arg'"
2243 >      as_fn_append ac_configure_args1 " '$ac_arg'"
2244        if test $ac_must_keep_next = true; then
2245          ac_must_keep_next=false # Got value, back to normal.
2246        else
# Line 1557 | Line 2256 | do
2256            -* ) ac_must_keep_next=true ;;
2257          esac
2258        fi
2259 <      ac_configure_args="$ac_configure_args '$ac_arg'"
2259 >      as_fn_append ac_configure_args " '$ac_arg'"
2260        ;;
2261      esac
2262    done
2263   done
2264 < $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
2265 < $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
2264 > { ac_configure_args0=; unset ac_configure_args0;}
2265 > { ac_configure_args1=; unset ac_configure_args1;}
2266  
2267   # When interrupted or exit'd, cleanup temporary files, and complete
2268   # config.log.  We remove comments because anyway the quotes in there
# Line 1575 | Line 2274 | trap 'exit_status=$?
2274    {
2275      echo
2276  
2277 <    cat <<\_ASBOX
1579 < ## ---------------- ##
2277 >    $as_echo "## ---------------- ##
2278   ## Cache variables. ##
2279 < ## ---------------- ##
1582 < _ASBOX
2279 > ## ---------------- ##"
2280      echo
2281      # The following way of writing the cache mishandles newlines in values,
2282   (
# Line 1588 | Line 2285 | _ASBOX
2285      case $ac_val in #(
2286      *${as_nl}*)
2287        case $ac_var in #(
2288 <      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
2289 < echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
2288 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
2289 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
2290        esac
2291        case $ac_var in #(
2292        _ | IFS | as_nl) ;; #(
2293 <      *) $as_unset $ac_var ;;
2293 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
2294 >      *) { eval $ac_var=; unset $ac_var;} ;;
2295        esac ;;
2296      esac
2297    done
# Line 1612 | Line 2310 | echo "$as_me: WARNING: Cache variable $ac_var contains
2310   )
2311      echo
2312  
2313 <    cat <<\_ASBOX
1616 < ## ----------------- ##
2313 >    $as_echo "## ----------------- ##
2314   ## Output variables. ##
2315 < ## ----------------- ##
1619 < _ASBOX
2315 > ## ----------------- ##"
2316      echo
2317      for ac_var in $ac_subst_vars
2318      do
2319        eval ac_val=\$$ac_var
2320        case $ac_val in
2321 <      *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2321 >      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2322        esac
2323 <      echo "$ac_var='\''$ac_val'\''"
2323 >      $as_echo "$ac_var='\''$ac_val'\''"
2324      done | sort
2325      echo
2326  
2327      if test -n "$ac_subst_files"; then
2328 <      cat <<\_ASBOX
1633 < ## ------------------- ##
2328 >      $as_echo "## ------------------- ##
2329   ## File substitutions. ##
2330 < ## ------------------- ##
1636 < _ASBOX
2330 > ## ------------------- ##"
2331        echo
2332        for ac_var in $ac_subst_files
2333        do
2334          eval ac_val=\$$ac_var
2335          case $ac_val in
2336 <        *\'\''*) ac_val=`echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2336 >        *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
2337          esac
2338 <        echo "$ac_var='\''$ac_val'\''"
2338 >        $as_echo "$ac_var='\''$ac_val'\''"
2339        done | sort
2340        echo
2341      fi
2342  
2343      if test -s confdefs.h; then
2344 <      cat <<\_ASBOX
1651 < ## ----------- ##
2344 >      $as_echo "## ----------- ##
2345   ## confdefs.h. ##
2346 < ## ----------- ##
1654 < _ASBOX
2346 > ## ----------- ##"
2347        echo
2348        cat confdefs.h
2349        echo
2350      fi
2351      test "$ac_signal" != 0 &&
2352 <      echo "$as_me: caught signal $ac_signal"
2353 <    echo "$as_me: exit $exit_status"
2352 >      $as_echo "$as_me: caught signal $ac_signal"
2353 >    $as_echo "$as_me: exit $exit_status"
2354    } >&5
2355    rm -f core *.core core.conftest.* &&
2356      rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
2357      exit $exit_status
2358   ' 0
2359   for ac_signal in 1 2 13 15; do
2360 <  trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
2360 >  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
2361   done
2362   ac_signal=0
2363  
2364   # confdefs.h avoids OS command line length limits that DEFS can exceed.
2365   rm -f -r conftest* confdefs.h
2366  
2367 + $as_echo "/* confdefs.h */" > confdefs.h
2368 +
2369   # Predefined preprocessor variables.
2370  
2371   cat >>confdefs.h <<_ACEOF
2372   #define PACKAGE_NAME "$PACKAGE_NAME"
2373   _ACEOF
2374  
1681 –
2375   cat >>confdefs.h <<_ACEOF
2376   #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
2377   _ACEOF
2378  
1686 –
2379   cat >>confdefs.h <<_ACEOF
2380   #define PACKAGE_VERSION "$PACKAGE_VERSION"
2381   _ACEOF
2382  
1691 –
2383   cat >>confdefs.h <<_ACEOF
2384   #define PACKAGE_STRING "$PACKAGE_STRING"
2385   _ACEOF
2386  
1696 –
2387   cat >>confdefs.h <<_ACEOF
2388   #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
2389   _ACEOF
2390  
2391 + cat >>confdefs.h <<_ACEOF
2392 + #define PACKAGE_URL "$PACKAGE_URL"
2393 + _ACEOF
2394  
2395 +
2396   # Let the site file select an alternate cache file if it wants to.
2397 < # Prefer explicitly selected file to automatically selected ones.
2397 > # Prefer an explicitly selected file to automatically selected ones.
2398 > ac_site_file1=NONE
2399 > ac_site_file2=NONE
2400   if test -n "$CONFIG_SITE"; then
2401 <  set x "$CONFIG_SITE"
2401 >  # We do not want a PATH search for config.site.
2402 >  case $CONFIG_SITE in #((
2403 >    -*)  ac_site_file1=./$CONFIG_SITE;;
2404 >    */*) ac_site_file1=$CONFIG_SITE;;
2405 >    *)   ac_site_file1=./$CONFIG_SITE;;
2406 >  esac
2407   elif test "x$prefix" != xNONE; then
2408 <  set x "$prefix/share/config.site" "$prefix/etc/config.site"
2408 >  ac_site_file1=$prefix/share/config.site
2409 >  ac_site_file2=$prefix/etc/config.site
2410   else
2411 <  set x "$ac_default_prefix/share/config.site" \
2412 <        "$ac_default_prefix/etc/config.site"
2411 >  ac_site_file1=$ac_default_prefix/share/config.site
2412 >  ac_site_file2=$ac_default_prefix/etc/config.site
2413   fi
2414 < shift
1713 < for ac_site_file
2414 > for ac_site_file in "$ac_site_file1" "$ac_site_file2"
2415   do
2416 <  if test -r "$ac_site_file"; then
2417 <    { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
2418 < echo "$as_me: loading site script $ac_site_file" >&6;}
2416 >  test "x$ac_site_file" = xNONE && continue
2417 >  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
2418 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
2419 > $as_echo "$as_me: loading site script $ac_site_file" >&6;}
2420      sed 's/^/| /' "$ac_site_file" >&5
2421 <    . "$ac_site_file"
2421 >    . "$ac_site_file" \
2422 >      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2423 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2424 > as_fn_error $? "failed to load site script $ac_site_file
2425 > See \`config.log' for more details" "$LINENO" 5; }
2426    fi
2427   done
2428  
2429   if test -r "$cache_file"; then
2430 <  # Some versions of bash will fail to source /dev/null (special
2431 <  # files actually), so we avoid doing that.
2432 <  if test -f "$cache_file"; then
2433 <    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
2434 < echo "$as_me: loading cache $cache_file" >&6;}
2430 >  # Some versions of bash will fail to source /dev/null (special files
2431 >  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
2432 >  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
2433 >    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
2434 > $as_echo "$as_me: loading cache $cache_file" >&6;}
2435      case $cache_file in
2436        [\\/]* | ?:[\\/]* ) . "$cache_file";;
2437        *)                      . "./$cache_file";;
2438      esac
2439    fi
2440   else
2441 <  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
2442 < echo "$as_me: creating cache $cache_file" >&6;}
2441 >  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
2442 > $as_echo "$as_me: creating cache $cache_file" >&6;}
2443    >$cache_file
2444   fi
2445  
# Line 1747 | Line 2453 | for ac_var in $ac_precious_vars; do
2453    eval ac_new_val=\$ac_env_${ac_var}_value
2454    case $ac_old_set,$ac_new_set in
2455      set,)
2456 <      { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2457 < echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2456 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
2457 > $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
2458        ac_cache_corrupted=: ;;
2459      ,set)
2460 <      { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
2461 < echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2460 >      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
2461 > $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
2462        ac_cache_corrupted=: ;;
2463      ,);;
2464      *)
2465        if test "x$ac_old_val" != "x$ac_new_val"; then
2466 <        { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
2467 < echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2468 <        { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
2469 < echo "$as_me:   former value:  $ac_old_val" >&2;}
2470 <        { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
2471 < echo "$as_me:   current value: $ac_new_val" >&2;}
2472 <        ac_cache_corrupted=:
2473 <      fi;;
2474 <  esac
2475 <  # Pass precious variables to config.status.
2476 <  if test "$ac_new_set" = set; then
2477 <    case $ac_new_val in
2478 <    *\'*) ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
2479 <    *) ac_arg=$ac_var=$ac_new_val ;;
2480 <    esac
2481 <    case " $ac_configure_args " in
2482 <      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
2483 <      *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
2466 >        # differences in whitespace do not lead to failure.
2467 >        ac_old_val_w=`echo x $ac_old_val`
2468 >        ac_new_val_w=`echo x $ac_new_val`
2469 >        if test "$ac_old_val_w" != "$ac_new_val_w"; then
2470 >          { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
2471 > $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
2472 >          ac_cache_corrupted=:
2473 >        else
2474 >          { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
2475 > $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
2476 >          eval $ac_var=\$ac_old_val
2477 >        fi
2478 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
2479 > $as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
2480 >        { $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
2481 > $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
2482 >      fi;;
2483 >  esac
2484 >  # Pass precious variables to config.status.
2485 >  if test "$ac_new_set" = set; then
2486 >    case $ac_new_val in
2487 >    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
2488 >    *) ac_arg=$ac_var=$ac_new_val ;;
2489      esac
2490 +    case " $ac_configure_args " in
2491 +      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
2492 +      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
2493 +    esac
2494    fi
2495   done
2496   if $ac_cache_corrupted; then
2497 <  { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
2498 < echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2499 <  { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
2500 < echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
2501 <   { (exit 1); exit 1; }; }
2497 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
2498 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2499 >  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
2500 > $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
2501 >  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
2502   fi
2503 + ## -------------------- ##
2504 + ## Main body of script. ##
2505 + ## -------------------- ##
2506  
1789 –
1790 –
1791 –
1792 –
1793 –
1794 –
1795 –
1796 –
1797 –
1798 –
1799 –
1800 –
1801 –
1802 –
1803 –
1804 –
1805 –
1806 –
1807 –
1808 –
1809 –
1810 –
1811 –
1812 –
2507   ac_ext=c
2508   ac_cpp='$CPP $CPPFLAGS'
2509   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
# Line 1834 | Line 2528 | if test -z "$ac_aux_dir"; then
2528    fi
2529   done
2530   if test -z "$ac_aux_dir"; then
2531 <  { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&5
1838 < echo "$as_me: error: cannot find install-sh or install.sh in ac-tools \"$srcdir\"/ac-tools" >&2;}
1839 <   { (exit 1); exit 1; }; }
2531 >  as_fn_error $? "cannot find install-sh, install.sh, or shtool in ac-tools \"$srcdir\"/ac-tools" "$LINENO" 5
2532   fi
2533  
2534   # These three variables are undocumented and unsupported,
# Line 1879 | Line 2571 | ac_config_headers="$ac_config_headers src/config.h"
2571  
2572  
2573  
1882 –
1883 –
1884 –
1885 –
1886 –
1887 –
1888 –
1889 –
1890 –
1891 –
1892 –
1893 –
1894 –
1895 –
1896 –
2574   #
2575   #
2576   #
# Line 1907 | Line 2584 | ac_config_headers="$ac_config_headers src/config.h"
2584  
2585  
2586  
1910 – # AC_F90_MODULE_NAMES
1911 – # -------------------
1912 – #
1913 – # Figure out how the Fortran 90 compiler constructs module file names
1914 – #
1915 – # AC_F90_MODULE_NAMES
2587  
2588  
2589  
# Line 2000 | Line 2671 | ac_config_headers="$ac_config_headers src/config.h"
2671  
2672  
2673  
2674 < # ACX_MPI_GET_PROG
2675 <
2676 < # ACX_DETECT_MPI_IMPLEMENTATION
2677 <
2678 <
2679 <
2680 <
2681 <
2682 < # ACX_MPI
2683 <
2684 <
2685 <
2686 <
2687 <
2688 <
2689 <
2690 <
2691 <
2692 <
2693 <
2694 <
2695 <
2696 <
2697 <
2698 <
2699 <
2700 <
2701 <
2702 <
2703 <
2704 <
2705 <
2706 <
2707 <
2708 <
2709 <
2710 < # This is taken from http://autoqt.sourceforge.net/
2711 < # Copyright (c) 2002, Geoffrey Wossum
2712 < # All rights reserved.
2713 <
2714 < # Redistribution and use in source and binary forms, with or without
2715 < # modification, are permitted provided that the following conditions are
2716 < # met:
2717 <
2718 < #  - Redistributions of source code must retain the above copyright notice,
2719 < #    this list of conditions and the following disclaimer.
2720 <
2721 < #  - Redistributions in binary form must reproduce the above copyright
2722 < #    notice, this list of conditions and the following disclaimer in the
2723 < #    documentation and/or other materials provided with the distribution.
2674 > # ===========================================================================
2675 > #             http://www.nongnu.org/autoconf-archive/ax_mpi.html
2676 > # ===========================================================================
2677 > #
2678 > # SYNOPSIS
2679 > #
2680 > #   AX_MPI([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
2681 > #
2682 > # DESCRIPTION
2683 > #
2684 > #   This macro tries to find out how to compile programs that use MPI
2685 > #   (Message Passing Interface), a standard API for parallel process
2686 > #   communication (see http://www-unix.mcs.anl.gov/mpi/)
2687 > #
2688 > #   On success, it sets the MPICC, MPICXX, MPIF77, or MPIFC output variable
2689 > #   to the name of the MPI compiler, depending upon the current language.
2690 > #   (This may just be $CC/$CXX/$F77/$FC, but is more often something like
2691 > #   mpicc/mpiCC/mpif77/mpif90.) It also sets MPILIBS to any libraries that
2692 > #   are needed for linking MPI (e.g. -lmpi or -lfmpi, if a special
2693 > #   MPICC/MPICXX/MPIF77/MPIFC was not found).
2694 > #
2695 > #   If you want to compile everything with MPI, you should set:
2696 > #
2697 > #       CC="MPICC" #OR# CXX="MPICXX" #OR# F77="MPIF77" #OR# FC="MPIFC"
2698 > #       LIBS="$MPILIBS $LIBS"
2699 > #
2700 > #   NOTE: The above assumes that you will use $CC (or whatever) for linking
2701 > #   as well as for compiling. (This is the default for automake and most
2702 > #   Makefiles.)
2703 > #
2704 > #   The user can force a particular library/compiler by setting the
2705 > #   MPICC/MPICXX/MPIF77/MPIFC and/or MPILIBS environment variables.
2706 > #
2707 > #   ACTION-IF-FOUND is a list of shell commands to run if an MPI library is
2708 > #   found, and ACTION-IF-NOT-FOUND is a list of commands to run if it is not
2709 > #   found. If ACTION-IF-FOUND is not specified, the default action will
2710 > #   define HAVE_MPI.
2711 > #
2712 > # LICENSE
2713 > #
2714 > #   Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
2715 > #   Copyright (c) 2008 Julian C. Cummings <cummings@cacr.caltech.edu>
2716 > #
2717 > #   This program is free software: you can redistribute it and/or modify it
2718 > #   under the terms of the GNU General Public License as published by the
2719 > #   Free Software Foundation, either version 3 of the License, or (at your
2720 > #   option) any later version.
2721 > #
2722 > #   This program is distributed in the hope that it will be useful, but
2723 > #   WITHOUT ANY WARRANTY; without even the implied warranty of
2724 > #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
2725 > #   Public License for more details.
2726 > #
2727 > #   You should have received a copy of the GNU General Public License along
2728 > #   with this program. If not, see <http://www.gnu.org/licenses/>.
2729 > #
2730 > #   As a special exception, the respective Autoconf Macro's copyright owner
2731 > #   gives unlimited permission to copy, distribute and modify the configure
2732 > #   scripts that are the output of Autoconf when processing the Macro. You
2733 > #   need not follow the terms of the GNU General Public License when using
2734 > #   or distributing such scripts, even though portions of the text of the
2735 > #   Macro appear in them. The GNU General Public License (GPL) does govern
2736 > #   all other use of the material that constitutes the Autoconf Macro.
2737 > #
2738 > #   This special exception to the GPL applies to versions of the Autoconf
2739 > #   Macro released by the Autoconf Archive. When you make and distribute a
2740 > #   modified version of the Autoconf Macro, you may extend this special
2741 > #   exception to the GPL to apply to your modified version as well.
2742  
2743 < #  - Neither the name of Geoffrey Wossum nor the names of its
2744 < #    contributors may be used to endorse or promote products derived from
2745 < #    this software without specific prior written permission.
2743 > # This is what autoupdate's m4 run will expand.  It fires
2744 > # the warning (with _au_warn_XXX), outputs it into the
2745 > # updated configure.ac (with AC_DIAGNOSE), and then outputs
2746 > # the replacement expansion.
2747  
2748  
2749 < # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
2750 < # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
2751 < # TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2752 < # PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
2753 < # CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
2064 < # EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
2065 < # PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
2066 < # OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
2067 < # WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
2068 < # OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
2069 < # ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2749 > # This is an auxiliary macro that is also run when
2750 > # autoupdate runs m4.  It simply calls m4_warning, but
2751 > # we need a wrapper so that each warning is emitted only
2752 > # once.  We break the quoting in m4_warning's argument in
2753 > # order to expand this macro's arguments, not AU_DEFUN's.
2754  
2755  
2756 < # Check for Qt compiler flags, linker flags, and binary packages
2756 > # Finally, this is the expansion that is picked up by
2757 > # autoconf.  It tells the user to run autoupdate, and
2758 > # then outputs the replacement expansion.  We do not care
2759 > # about autoupdate's warning because that contains
2760 > # information on what to do *after* running autoupdate.
2761  
2762  
2763  
2764   # who am i
2765   # Make sure we can run config.sub.
2766   $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
2767 <  { { echo "$as_me:$LINENO: error: cannot run $SHELL $ac_aux_dir/config.sub" >&5
2080 < echo "$as_me: error: cannot run $SHELL $ac_aux_dir/config.sub" >&2;}
2081 <   { (exit 1); exit 1; }; }
2767 >  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
2768  
2769 < { echo "$as_me:$LINENO: checking build system type" >&5
2770 < echo $ECHO_N "checking build system type... $ECHO_C" >&6; }
2771 < if test "${ac_cv_build+set}" = set; then
2772 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2769 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
2770 > $as_echo_n "checking build system type... " >&6; }
2771 > if ${ac_cv_build+:} false; then :
2772 >  $as_echo_n "(cached) " >&6
2773   else
2774    ac_build_alias=$build_alias
2775   test "x$ac_build_alias" = x &&
2776    ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
2777   test "x$ac_build_alias" = x &&
2778 <  { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
2093 < echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
2094 <   { (exit 1); exit 1; }; }
2778 >  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
2779   ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
2780 <  { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&5
2097 < echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $ac_build_alias failed" >&2;}
2098 <   { (exit 1); exit 1; }; }
2780 >  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
2781  
2782   fi
2783 < { echo "$as_me:$LINENO: result: $ac_cv_build" >&5
2784 < echo "${ECHO_T}$ac_cv_build" >&6; }
2783 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
2784 > $as_echo "$ac_cv_build" >&6; }
2785   case $ac_cv_build in
2786   *-*-*) ;;
2787 < *) { { echo "$as_me:$LINENO: error: invalid value of canonical build" >&5
2106 < echo "$as_me: error: invalid value of canonical build" >&2;}
2107 <   { (exit 1); exit 1; }; };;
2787 > *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
2788   esac
2789   build=$ac_cv_build
2790   ac_save_IFS=$IFS; IFS='-'
# Line 2120 | Line 2800 | case $build_os in *\ *) build_os=`echo "$build_os" | s
2800   case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
2801  
2802  
2803 < { echo "$as_me:$LINENO: checking host system type" >&5
2804 < echo $ECHO_N "checking host system type... $ECHO_C" >&6; }
2805 < if test "${ac_cv_host+set}" = set; then
2806 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2803 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
2804 > $as_echo_n "checking host system type... " >&6; }
2805 > if ${ac_cv_host+:} false; then :
2806 >  $as_echo_n "(cached) " >&6
2807   else
2808    if test "x$host_alias" = x; then
2809    ac_cv_host=$ac_cv_build
2810   else
2811    ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
2812 <    { { echo "$as_me:$LINENO: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&5
2133 < echo "$as_me: error: $SHELL $ac_aux_dir/config.sub $host_alias failed" >&2;}
2134 <   { (exit 1); exit 1; }; }
2812 >    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
2813   fi
2814  
2815   fi
2816 < { echo "$as_me:$LINENO: result: $ac_cv_host" >&5
2817 < echo "${ECHO_T}$ac_cv_host" >&6; }
2816 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
2817 > $as_echo "$ac_cv_host" >&6; }
2818   case $ac_cv_host in
2819   *-*-*) ;;
2820 < *) { { echo "$as_me:$LINENO: error: invalid value of canonical host" >&5
2143 < echo "$as_me: error: invalid value of canonical host" >&2;}
2144 <   { (exit 1); exit 1; }; };;
2820 > *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
2821   esac
2822   host=$ac_cv_host
2823   ac_save_IFS=$IFS; IFS='-'
# Line 2161 | Line 2837 | case $host_os in *\ *) host_os=`echo "$host_os" | sed
2837  
2838  
2839   # set program name
2840 < PROGNAME="oopse"
2840 > PROGNAME="openmd"
2841  
2842  
2843  
2844  
2845   OBJEXT=".$OBJEXT"
2846  
2847 < OOPSE=oopse
2847 > OPENMD=openmd
2848  
2849   if test "x${prefix}" = "xNONE"
2850   then
2851 <  OOPSE_HOME=${ac_default_prefix}/oopse
2851 >  OPENMD_HOME=${ac_default_prefix}/openmd
2852   else
2853 <  OOPSE_HOME=${prefix}/oopse
2853 >  OPENMD_HOME=${prefix}/openmd
2854   fi
2855 < # Check whether --enable-oopse-home was given.
2856 < if test "${enable_oopse_home+set}" = set; then
2857 <  enableval=$enable_oopse_home; OOPSE_HOME="${enableval}"
2855 > # Check whether --enable-openmd-home was given.
2856 > if test "${enable_openmd_home+set}" = set; then :
2857 >  enableval=$enable_openmd_home; OPENMD_HOME="${enableval}"
2858   fi
2859  
2860  
# Line 2187 | Line 2863 | debug=0
2863  
2864   debug=0
2865   # Check whether --enable-debug was given.
2866 < if test "${enable_debug+set}" = set; then
2866 > if test "${enable_debug+set}" = set; then :
2867    enableval=$enable_debug; debug=1
2868   fi
2869  
2870   if test "${DEBUG}"; then
2871  
2872 < cat >>confdefs.h <<\_ACEOF
2197 < #define debug 1
2198 < _ACEOF
2872 > $as_echo "#define debug 1" >>confdefs.h
2873  
2874    msg="$msg, debug mode"
2875   fi
2876  
2877  
2878   # Check whether --enable-single was given.
2879 < if test "${enable_single+set}" = set; then
2879 > if test "${enable_single+set}" = set; then :
2880    enableval=$enable_single; ok=$enableval
2881   else
2882    ok=no
2883   fi
2884  
2885   # Check whether --enable-float was given.
2886 < if test "${enable_float+set}" = set; then
2886 > if test "${enable_float+set}" = set; then :
2887    enableval=$enable_float; ok=$enableval
2888   fi
2889  
2890   if test "$ok" = "yes"; then
2891  
2892 < cat >>confdefs.h <<\_ACEOF
2219 < #define SINGLE_PRECISION 1
2220 < _ACEOF
2892 > $as_echo "#define SINGLE_PRECISION 1" >>confdefs.h
2893  
2894          USE_SINGLE_PRECISION=yes
2895  
2896   fi
2897  
2898 < if test x"$CC" != x; then
2899 <   for ac_prog in $CC
2900 < do
2901 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
2902 < set dummy $ac_prog; ac_word=$2
2903 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
2904 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2905 < if test "${ac_cv_prog_ac_cc_set+set}" = set; then
2906 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2898 > ac_ext=cpp
2899 > ac_cpp='$CXXCPP $CPPFLAGS'
2900 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2901 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2902 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2903 > if test -z "$CXX"; then
2904 >  if test -n "$CCC"; then
2905 >    CXX=$CCC
2906 >  else
2907 >    if test -n "$ac_tool_prefix"; then
2908 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2909 >  do
2910 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2911 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2912 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2913 > $as_echo_n "checking for $ac_word... " >&6; }
2914 > if ${ac_cv_prog_CXX+:} false; then :
2915 >  $as_echo_n "(cached) " >&6
2916   else
2917 <  if test -n "$ac_cc_set"; then
2918 <  ac_cv_prog_ac_cc_set="$ac_cc_set" # Let the user override the test.
2917 >  if test -n "$CXX"; then
2918 >  ac_cv_prog_CXX="$CXX" # Let the user override the test.
2919   else
2920   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2921   for as_dir in $PATH
2922   do
2923    IFS=$as_save_IFS
2924    test -z "$as_dir" && as_dir=.
2925 <  for ac_exec_ext in '' $ac_executable_extensions; do
2925 >    for ac_exec_ext in '' $ac_executable_extensions; do
2926    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2927 <    ac_cv_prog_ac_cc_set="$ac_prog"
2928 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2927 >    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
2928 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2929      break 2
2930    fi
2931   done
2932 < done
2932 >  done
2933   IFS=$as_save_IFS
2934  
2935   fi
2936   fi
2937 < ac_cc_set=$ac_cv_prog_ac_cc_set
2938 < if test -n "$ac_cc_set"; then
2939 <  { echo "$as_me:$LINENO: result: $ac_cc_set" >&5
2940 < echo "${ECHO_T}$ac_cc_set" >&6; }
2937 > CXX=$ac_cv_prog_CXX
2938 > if test -n "$CXX"; then
2939 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
2940 > $as_echo "$CXX" >&6; }
2941   else
2942 <  { echo "$as_me:$LINENO: result: no" >&5
2943 < echo "${ECHO_T}no" >&6; }
2942 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2943 > $as_echo "no" >&6; }
2944   fi
2945  
2946  
2947 <  test -n "$ac_cc_set" && break
2948 < done
2949 < test -n "$ac_cc_set" || ac_cc_set="no"
2950 <
2951 <   if test $ac_cc_set != no; then
2952 <
2953 <     # Extract the first word of "$ac_cc_set", so it can be a program name with args.
2954 < set dummy $ac_cc_set; ac_word=$2
2955 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
2956 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2957 < if test "${ac_cv_path_ac_cc_path+set}" = set; then
2958 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2947 >    test -n "$CXX" && break
2948 >  done
2949 > fi
2950 > if test -z "$CXX"; then
2951 >  ac_ct_CXX=$CXX
2952 >  for ac_prog in $CXX icpc pathCC pgCC c++ xlc++ xlC g++ CC
2953 > do
2954 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
2955 > set dummy $ac_prog; ac_word=$2
2956 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
2957 > $as_echo_n "checking for $ac_word... " >&6; }
2958 > if ${ac_cv_prog_ac_ct_CXX+:} false; then :
2959 >  $as_echo_n "(cached) " >&6
2960   else
2961 <  case $ac_cc_path in
2962 <  [\\/]* | ?:[\\/]*)
2963 <  ac_cv_path_ac_cc_path="$ac_cc_path" # Let the user override the test with a path.
2964 <  ;;
2283 <  *)
2284 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2961 >  if test -n "$ac_ct_CXX"; then
2962 >  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
2963 > else
2964 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2965   for as_dir in $PATH
2966   do
2967    IFS=$as_save_IFS
2968    test -z "$as_dir" && as_dir=.
2969 <  for ac_exec_ext in '' $ac_executable_extensions; do
2969 >    for ac_exec_ext in '' $ac_executable_extensions; do
2970    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2971 <    ac_cv_path_ac_cc_path="$as_dir/$ac_word$ac_exec_ext"
2972 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2971 >    ac_cv_prog_ac_ct_CXX="$ac_prog"
2972 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
2973      break 2
2974    fi
2975   done
2976 < done
2976 >  done
2977   IFS=$as_save_IFS
2978  
2299 –  test -z "$ac_cv_path_ac_cc_path" && ac_cv_path_ac_cc_path="no"
2300 –  ;;
2301 – esac
2979   fi
2980 < ac_cc_path=$ac_cv_path_ac_cc_path
2981 < if test -n "$ac_cc_path"; then
2982 <  { echo "$as_me:$LINENO: result: $ac_cc_path" >&5
2983 < echo "${ECHO_T}$ac_cc_path" >&6; }
2980 > fi
2981 > ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2982 > if test -n "$ac_ct_CXX"; then
2983 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
2984 > $as_echo "$ac_ct_CXX" >&6; }
2985   else
2986 <  { echo "$as_me:$LINENO: result: no" >&5
2987 < echo "${ECHO_T}no" >&6; }
2986 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
2987 > $as_echo "no" >&6; }
2988   fi
2989  
2990  
2991 < else
2991 >  test -n "$ac_ct_CXX" && break
2992 > done
2993  
2994 <     { { echo "$as_me:$LINENO: error: Specified C compiler $CC doesn't seem to exist!" >&5
2995 < echo "$as_me: error: Specified C compiler $CC doesn't seem to exist!" >&2;}
2996 <   { (exit 1); exit 1; }; }
2994 >  if test "x$ac_ct_CXX" = x; then
2995 >    CXX="g++"
2996 >  else
2997 >    case $cross_compiling:$ac_tool_warned in
2998 > yes:)
2999 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3000 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3001 > ac_tool_warned=yes ;;
3002 > esac
3003 >    CXX=$ac_ct_CXX
3004 >  fi
3005   fi
3006  
3007 +  fi
3008 + fi
3009 + # Provide some information about the compiler.
3010 + $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
3011 + set X $ac_compile
3012 + ac_compiler=$2
3013 + for ac_option in --version -v -V -qversion; do
3014 +  { { ac_try="$ac_compiler $ac_option >&5"
3015 + case "(($ac_try" in
3016 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3017 +  *) ac_try_echo=$ac_try;;
3018 + esac
3019 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3020 + $as_echo "$ac_try_echo"; } >&5
3021 +  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3022 +  ac_status=$?
3023 +  if test -s conftest.err; then
3024 +    sed '10a\
3025 + ... rest of stderr output deleted ...
3026 +         10q' conftest.err >conftest.er1
3027 +    cat conftest.er1 >&5
3028 +  fi
3029 +  rm -f conftest.er1 conftest.err
3030 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3031 +  test $ac_status = 0; }
3032 + done
3033  
3034 <   if test $ac_cc_path != no; then
3034 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3035 > /* end confdefs.h.  */
3036  
3037 <     { echo "$as_me:$LINENO: Will attempt to use $CC as C compiler" >&5
3038 < echo "$as_me: Will attempt to use $CC as C compiler" >&6;}
3039 < else
3037 > int
3038 > main ()
3039 > {
3040  
3041 <     { { echo "$as_me:$LINENO: error: Can't find path to user-specified C compiler $CC" >&5
3042 < echo "$as_me: error: Can't find path to user-specified C compiler $CC" >&2;}
3043 <   { (exit 1); exit 1; }; }
3044 < fi
3041 >  ;
3042 >  return 0;
3043 > }
3044 > _ACEOF
3045 > ac_clean_files_save=$ac_clean_files
3046 > ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
3047 > # Try to create an executable without -o first, disregard a.out.
3048 > # It will help us diagnose broken compilers, and finding out an intuition
3049 > # of exeext.
3050 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
3051 > $as_echo_n "checking whether the C++ compiler works... " >&6; }
3052 > ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3053  
3054 < fi
3054 > # The possible output files:
3055 > ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
3056  
3057 < if test x"$CXX" != x; then
3058 <   for ac_prog in $CXX
3057 > ac_rmfiles=
3058 > for ac_file in $ac_files
3059   do
3060 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3061 < set dummy $ac_prog; ac_word=$2
3062 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3063 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2341 < if test "${ac_cv_prog_ac_cxx_set+set}" = set; then
2342 <  echo $ECHO_N "(cached) $ECHO_C" >&6
2343 < else
2344 <  if test -n "$ac_cxx_set"; then
2345 <  ac_cv_prog_ac_cxx_set="$ac_cxx_set" # Let the user override the test.
2346 < else
2347 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2348 < for as_dir in $PATH
2349 < do
2350 <  IFS=$as_save_IFS
2351 <  test -z "$as_dir" && as_dir=.
2352 <  for ac_exec_ext in '' $ac_executable_extensions; do
2353 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2354 <    ac_cv_prog_ac_cxx_set="$ac_prog"
2355 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2356 <    break 2
2357 <  fi
3060 >  case $ac_file in
3061 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3062 >    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3063 >  esac
3064   done
3065 < done
2360 < IFS=$as_save_IFS
3065 > rm -f $ac_rmfiles
3066  
3067 + if { { ac_try="$ac_link_default"
3068 + case "(($ac_try" in
3069 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3070 +  *) ac_try_echo=$ac_try;;
3071 + esac
3072 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3073 + $as_echo "$ac_try_echo"; } >&5
3074 +  (eval "$ac_link_default") 2>&5
3075 +  ac_status=$?
3076 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3077 +  test $ac_status = 0; }; then :
3078 +  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3079 + # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3080 + # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3081 + # so that the user can short-circuit this test for compilers unknown to
3082 + # Autoconf.
3083 + for ac_file in $ac_files ''
3084 + do
3085 +  test -f "$ac_file" || continue
3086 +  case $ac_file in
3087 +    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
3088 +        ;;
3089 +    [ab].out )
3090 +        # We found the default executable, but exeext='' is most
3091 +        # certainly right.
3092 +        break;;
3093 +    *.* )
3094 +        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3095 +        then :; else
3096 +           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3097 +        fi
3098 +        # We set ac_cv_exeext here because the later test for it is not
3099 +        # safe: cross compilers may not add the suffix if given an `-o'
3100 +        # argument, so we may need to know it at that point already.
3101 +        # Even if this section looks crufty: it has the advantage of
3102 +        # actually working.
3103 +        break;;
3104 +    * )
3105 +        break;;
3106 +  esac
3107 + done
3108 + test "$ac_cv_exeext" = no && ac_cv_exeext=
3109 +
3110 + else
3111 +  ac_file=''
3112   fi
3113 < fi
3114 < ac_cxx_set=$ac_cv_prog_ac_cxx_set
3115 < if test -n "$ac_cxx_set"; then
3116 <  { echo "$as_me:$LINENO: result: $ac_cxx_set" >&5
3117 < echo "${ECHO_T}$ac_cxx_set" >&6; }
3113 > if test -z "$ac_file"; then :
3114 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3115 > $as_echo "no" >&6; }
3116 > $as_echo "$as_me: failed program was:" >&5
3117 > sed 's/^/| /' conftest.$ac_ext >&5
3118 >
3119 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3120 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3121 > as_fn_error 77 "C++ compiler cannot create executables
3122 > See \`config.log' for more details" "$LINENO" 5; }
3123   else
3124 <  { echo "$as_me:$LINENO: result: no" >&5
3125 < echo "${ECHO_T}no" >&6; }
3124 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
3125 > $as_echo "yes" >&6; }
3126   fi
3127 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
3128 + $as_echo_n "checking for C++ compiler default output file name... " >&6; }
3129 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
3130 + $as_echo "$ac_file" >&6; }
3131 + ac_exeext=$ac_cv_exeext
3132  
3133 <
3134 <  test -n "$ac_cxx_set" && break
3133 > rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
3134 > ac_clean_files=$ac_clean_files_save
3135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
3136 > $as_echo_n "checking for suffix of executables... " >&6; }
3137 > if { { ac_try="$ac_link"
3138 > case "(($ac_try" in
3139 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3140 >  *) ac_try_echo=$ac_try;;
3141 > esac
3142 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3143 > $as_echo "$ac_try_echo"; } >&5
3144 >  (eval "$ac_link") 2>&5
3145 >  ac_status=$?
3146 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3147 >  test $ac_status = 0; }; then :
3148 >  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3149 > # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3150 > # work properly (i.e., refer to `conftest.exe'), while it won't with
3151 > # `rm'.
3152 > for ac_file in conftest.exe conftest conftest.*; do
3153 >  test -f "$ac_file" || continue
3154 >  case $ac_file in
3155 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
3156 >    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3157 >          break;;
3158 >    * ) break;;
3159 >  esac
3160   done
3161 < test -n "$ac_cxx_set" || ac_cxx_set="no"
3161 > else
3162 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3163 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3164 > as_fn_error $? "cannot compute suffix of executables: cannot compile and link
3165 > See \`config.log' for more details" "$LINENO" 5; }
3166 > fi
3167 > rm -f conftest conftest$ac_cv_exeext
3168 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
3169 > $as_echo "$ac_cv_exeext" >&6; }
3170  
3171 <   if test $ac_cxx_set != no; then
3171 > rm -f conftest.$ac_ext
3172 > EXEEXT=$ac_cv_exeext
3173 > ac_exeext=$EXEEXT
3174 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3175 > /* end confdefs.h.  */
3176 > #include <stdio.h>
3177 > int
3178 > main ()
3179 > {
3180 > FILE *f = fopen ("conftest.out", "w");
3181 > return ferror (f) || fclose (f) != 0;
3182  
3183 <     # Extract the first word of "$ac_cxx_set", so it can be a program name with args.
3184 < set dummy $ac_cxx_set; ac_word=$2
3185 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3186 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3187 < if test "${ac_cv_path_ac_cxx_path+set}" = set; then
3188 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3189 < else
3190 <  case $ac_cxx_path in
3191 <  [\\/]* | ?:[\\/]*)
3192 <  ac_cv_path_ac_cxx_path="$ac_cxx_path" # Let the user override the test with a path.
3193 <  ;;
3194 <  *)
3195 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3196 < for as_dir in $PATH
3197 < do
3198 <  IFS=$as_save_IFS
3199 <  test -z "$as_dir" && as_dir=.
3200 <  for ac_exec_ext in '' $ac_executable_extensions; do
3201 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3202 <    ac_cv_path_ac_cxx_path="$as_dir/$ac_word$ac_exec_ext"
3203 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3204 <    break 2
3183 >  ;
3184 >  return 0;
3185 > }
3186 > _ACEOF
3187 > ac_clean_files="$ac_clean_files conftest.out"
3188 > # Check that the compiler produces executables we can run.  If not, either
3189 > # the compiler is broken, or we cross compile.
3190 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
3191 > $as_echo_n "checking whether we are cross compiling... " >&6; }
3192 > if test "$cross_compiling" != yes; then
3193 >  { { ac_try="$ac_link"
3194 > case "(($ac_try" in
3195 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3196 >  *) ac_try_echo=$ac_try;;
3197 > esac
3198 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3199 > $as_echo "$ac_try_echo"; } >&5
3200 >  (eval "$ac_link") 2>&5
3201 >  ac_status=$?
3202 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3203 >  test $ac_status = 0; }
3204 >  if { ac_try='./conftest$ac_cv_exeext'
3205 >  { { case "(($ac_try" in
3206 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3207 >  *) ac_try_echo=$ac_try;;
3208 > esac
3209 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3210 > $as_echo "$ac_try_echo"; } >&5
3211 >  (eval "$ac_try") 2>&5
3212 >  ac_status=$?
3213 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3214 >  test $ac_status = 0; }; }; then
3215 >    cross_compiling=no
3216 >  else
3217 >    if test "$cross_compiling" = maybe; then
3218 >        cross_compiling=yes
3219 >    else
3220 >        { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3221 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3222 > as_fn_error $? "cannot run C++ compiled programs.
3223 > If you meant to cross compile, use \`--host'.
3224 > See \`config.log' for more details" "$LINENO" 5; }
3225 >    fi
3226    fi
3227 < done
3228 < done
3229 < IFS=$as_save_IFS
3227 > fi
3228 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
3229 > $as_echo "$cross_compiling" >&6; }
3230  
3231 <  test -z "$ac_cv_path_ac_cxx_path" && ac_cv_path_ac_cxx_path="no"
3232 <  ;;
3231 > rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
3232 > ac_clean_files=$ac_clean_files_save
3233 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
3234 > $as_echo_n "checking for suffix of object files... " >&6; }
3235 > if ${ac_cv_objext+:} false; then :
3236 >  $as_echo_n "(cached) " >&6
3237 > else
3238 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3239 > /* end confdefs.h.  */
3240 >
3241 > int
3242 > main ()
3243 > {
3244 >
3245 >  ;
3246 >  return 0;
3247 > }
3248 > _ACEOF
3249 > rm -f conftest.o conftest.obj
3250 > if { { ac_try="$ac_compile"
3251 > case "(($ac_try" in
3252 >  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3253 >  *) ac_try_echo=$ac_try;;
3254   esac
3255 < fi
3256 < ac_cxx_path=$ac_cv_path_ac_cxx_path
3257 < if test -n "$ac_cxx_path"; then
3258 <  { echo "$as_me:$LINENO: result: $ac_cxx_path" >&5
3259 < echo "${ECHO_T}$ac_cxx_path" >&6; }
3255 > eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3256 > $as_echo "$ac_try_echo"; } >&5
3257 >  (eval "$ac_compile") 2>&5
3258 >  ac_status=$?
3259 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3260 >  test $ac_status = 0; }; then :
3261 >  for ac_file in conftest.o conftest.obj conftest.*; do
3262 >  test -f "$ac_file" || continue;
3263 >  case $ac_file in
3264 >    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
3265 >    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3266 >       break;;
3267 >  esac
3268 > done
3269   else
3270 <  { echo "$as_me:$LINENO: result: no" >&5
3271 < echo "${ECHO_T}no" >&6; }
3270 >  $as_echo "$as_me: failed program was:" >&5
3271 > sed 's/^/| /' conftest.$ac_ext >&5
3272 >
3273 > { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3274 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3275 > as_fn_error $? "cannot compute suffix of object files: cannot compile
3276 > See \`config.log' for more details" "$LINENO" 5; }
3277   fi
3278 + rm -f conftest.$ac_cv_objext conftest.$ac_ext
3279 + fi
3280 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
3281 + $as_echo "$ac_cv_objext" >&6; }
3282 + OBJEXT=$ac_cv_objext
3283 + ac_objext=$OBJEXT
3284 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
3285 + $as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
3286 + if ${ac_cv_cxx_compiler_gnu+:} false; then :
3287 +  $as_echo_n "(cached) " >&6
3288 + else
3289 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3290 + /* end confdefs.h.  */
3291  
3292 + int
3293 + main ()
3294 + {
3295 + #ifndef __GNUC__
3296 +       choke me
3297 + #endif
3298  
3299 +  ;
3300 +  return 0;
3301 + }
3302 + _ACEOF
3303 + if ac_fn_cxx_try_compile "$LINENO"; then :
3304 +  ac_compiler_gnu=yes
3305   else
3306 +  ac_compiler_gnu=no
3307 + fi
3308 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3309 + ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3310  
2423 –     { { echo "$as_me:$LINENO: error: Specified C++ compiler $CXX doesn't seem to exist!" >&5
2424 – echo "$as_me: error: Specified C++ compiler $CXX doesn't seem to exist!" >&2;}
2425 –   { (exit 1); exit 1; }; }
3311   fi
3312 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
3313 + $as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
3314 + if test $ac_compiler_gnu = yes; then
3315 +  GXX=yes
3316 + else
3317 +  GXX=
3318 + fi
3319 + ac_test_CXXFLAGS=${CXXFLAGS+set}
3320 + ac_save_CXXFLAGS=$CXXFLAGS
3321 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
3322 + $as_echo_n "checking whether $CXX accepts -g... " >&6; }
3323 + if ${ac_cv_prog_cxx_g+:} false; then :
3324 +  $as_echo_n "(cached) " >&6
3325 + else
3326 +  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
3327 +   ac_cxx_werror_flag=yes
3328 +   ac_cv_prog_cxx_g=no
3329 +   CXXFLAGS="-g"
3330 +   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3331 + /* end confdefs.h.  */
3332  
3333 + int
3334 + main ()
3335 + {
3336  
3337 <   if test $ac_cxx_path != no; then
3337 >  ;
3338 >  return 0;
3339 > }
3340 > _ACEOF
3341 > if ac_fn_cxx_try_compile "$LINENO"; then :
3342 >  ac_cv_prog_cxx_g=yes
3343 > else
3344 >  CXXFLAGS=""
3345 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3346 > /* end confdefs.h.  */
3347  
3348 <     { echo "$as_me:$LINENO: Will attempt to use $CXX as C++ compiler" >&5
3349 < echo "$as_me: Will attempt to use $CXX as C++ compiler" >&6;}
3348 > int
3349 > main ()
3350 > {
3351 >
3352 >  ;
3353 >  return 0;
3354 > }
3355 > _ACEOF
3356 > if ac_fn_cxx_try_compile "$LINENO"; then :
3357 >
3358   else
3359 +  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3360 +         CXXFLAGS="-g"
3361 +         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3362 + /* end confdefs.h.  */
3363  
3364 <     { { echo "$as_me:$LINENO: error: Can't find path to user-specified C++ compiler $CXX" >&5
3365 < echo "$as_me: error: Can't find path to user-specified C++ compiler $CXX" >&2;}
3366 <   { (exit 1); exit 1; }; }
2438 < fi
3364 > int
3365 > main ()
3366 > {
3367  
3368 +  ;
3369 +  return 0;
3370 + }
3371 + _ACEOF
3372 + if ac_fn_cxx_try_compile "$LINENO"; then :
3373 +  ac_cv_prog_cxx_g=yes
3374   fi
3375 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3376 + fi
3377 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3378 + fi
3379 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3380 +   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3381 + fi
3382 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
3383 + $as_echo "$ac_cv_prog_cxx_g" >&6; }
3384 + if test "$ac_test_CXXFLAGS" = set; then
3385 +  CXXFLAGS=$ac_save_CXXFLAGS
3386 + elif test $ac_cv_prog_cxx_g = yes; then
3387 +  if test "$GXX" = yes; then
3388 +    CXXFLAGS="-g -O2"
3389 +  else
3390 +    CXXFLAGS="-g"
3391 +  fi
3392 + else
3393 +  if test "$GXX" = yes; then
3394 +    CXXFLAGS="-O2"
3395 +  else
3396 +    CXXFLAGS=
3397 +  fi
3398 + fi
3399 + ac_ext=c
3400 + ac_cpp='$CPP $CPPFLAGS'
3401 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3402 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3403 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
3404  
3405 < if test x"$FC" != x; then
3406 <   for ac_prog in $FC
3407 < do
3408 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3409 < set dummy $ac_prog; ac_word=$2
3410 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3411 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3412 < if test "${ac_cv_prog_ac_fc_set+set}" = set; then
3413 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3405 > ac_ext=c
3406 > ac_cpp='$CPP $CPPFLAGS'
3407 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3408 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3409 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
3410 > if test -n "$ac_tool_prefix"; then
3411 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3412 >  do
3413 >    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3414 > set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3415 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3416 > $as_echo_n "checking for $ac_word... " >&6; }
3417 > if ${ac_cv_prog_CC+:} false; then :
3418 >  $as_echo_n "(cached) " >&6
3419   else
3420 <  if test -n "$ac_fc_set"; then
3421 <  ac_cv_prog_ac_fc_set="$ac_fc_set" # Let the user override the test.
3420 >  if test -n "$CC"; then
3421 >  ac_cv_prog_CC="$CC" # Let the user override the test.
3422   else
3423   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3424   for as_dir in $PATH
3425   do
3426    IFS=$as_save_IFS
3427    test -z "$as_dir" && as_dir=.
3428 <  for ac_exec_ext in '' $ac_executable_extensions; do
3428 >    for ac_exec_ext in '' $ac_executable_extensions; do
3429    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3430 <    ac_cv_prog_ac_fc_set="$ac_prog"
3431 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3430 >    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3431 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3432      break 2
3433    fi
3434   done
3435 < done
3435 >  done
3436   IFS=$as_save_IFS
3437  
3438   fi
3439   fi
3440 < ac_fc_set=$ac_cv_prog_ac_fc_set
3441 < if test -n "$ac_fc_set"; then
3442 <  { echo "$as_me:$LINENO: result: $ac_fc_set" >&5
3443 < echo "${ECHO_T}$ac_fc_set" >&6; }
3440 > CC=$ac_cv_prog_CC
3441 > if test -n "$CC"; then
3442 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
3443 > $as_echo "$CC" >&6; }
3444   else
3445 <  { echo "$as_me:$LINENO: result: no" >&5
3446 < echo "${ECHO_T}no" >&6; }
3445 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3446 > $as_echo "no" >&6; }
3447   fi
3448  
3449  
3450 <  test -n "$ac_fc_set" && break
3451 < done
3452 < test -n "$ac_fc_set" || ac_fc_set="no"
3453 <
3454 <   if test $ac_fc_set != no; then
3455 <
3456 <     # Extract the first word of "$ac_fc_set", so it can be a program name with args.
3457 < set dummy $ac_fc_set; ac_word=$2
3458 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3459 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3460 < if test "${ac_cv_path_ac_fc_path+set}" = set; then
3461 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3450 >    test -n "$CC" && break
3451 >  done
3452 > fi
3453 > if test -z "$CC"; then
3454 >  ac_ct_CC=$CC
3455 >  for ac_prog in $CC icc pathcc pgcc cc xlc gcc
3456 > do
3457 >  # Extract the first word of "$ac_prog", so it can be a program name with args.
3458 > set dummy $ac_prog; ac_word=$2
3459 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3460 > $as_echo_n "checking for $ac_word... " >&6; }
3461 > if ${ac_cv_prog_ac_ct_CC+:} false; then :
3462 >  $as_echo_n "(cached) " >&6
3463   else
3464 <  case $ac_fc_path in
3465 <  [\\/]* | ?:[\\/]*)
3466 <  ac_cv_path_ac_fc_path="$ac_fc_path" # Let the user override the test with a path.
3467 <  ;;
2499 <  *)
2500 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3464 >  if test -n "$ac_ct_CC"; then
3465 >  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3466 > else
3467 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3468   for as_dir in $PATH
3469   do
3470    IFS=$as_save_IFS
3471    test -z "$as_dir" && as_dir=.
3472 <  for ac_exec_ext in '' $ac_executable_extensions; do
3472 >    for ac_exec_ext in '' $ac_executable_extensions; do
3473    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3474 <    ac_cv_path_ac_fc_path="$as_dir/$ac_word$ac_exec_ext"
3475 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3474 >    ac_cv_prog_ac_ct_CC="$ac_prog"
3475 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3476      break 2
3477    fi
3478   done
3479 < done
3479 >  done
3480   IFS=$as_save_IFS
3481  
2515 –  test -z "$ac_cv_path_ac_fc_path" && ac_cv_path_ac_fc_path="no"
2516 –  ;;
2517 – esac
3482   fi
2519 – ac_fc_path=$ac_cv_path_ac_fc_path
2520 – if test -n "$ac_fc_path"; then
2521 –  { echo "$as_me:$LINENO: result: $ac_fc_path" >&5
2522 – echo "${ECHO_T}$ac_fc_path" >&6; }
2523 – else
2524 –  { echo "$as_me:$LINENO: result: no" >&5
2525 – echo "${ECHO_T}no" >&6; }
3483   fi
3484 <
3485 <
3484 > ac_ct_CC=$ac_cv_prog_ac_ct_CC
3485 > if test -n "$ac_ct_CC"; then
3486 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
3487 > $as_echo "$ac_ct_CC" >&6; }
3488   else
3489 <
3490 <     { { echo "$as_me:$LINENO: error: Specified Fortran compiler $FC doesn't seem to exist!" >&5
2532 < echo "$as_me: error: Specified Fortran compiler $FC doesn't seem to exist!" >&2;}
2533 <   { (exit 1); exit 1; }; }
3489 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3490 > $as_echo "no" >&6; }
3491   fi
3492  
3493  
3494 <   if test $ac_fc_path != no; then
3494 >  test -n "$ac_ct_CC" && break
3495 > done
3496  
3497 <     { echo "$as_me:$LINENO: Will attempt to use $FC as Fortran compiler" >&5
3498 < echo "$as_me: Will attempt to use $FC as Fortran compiler" >&6;}
3499 < else
3500 <
3501 <     { { echo "$as_me:$LINENO: error: Can't find path to user-specified Fortran compiler $FC" >&5
3502 < echo "$as_me: error: Can't find path to user-specified Fortran compiler $FC" >&2;}
3503 <   { (exit 1); exit 1; }; }
3497 >  if test "x$ac_ct_CC" = x; then
3498 >    CC=""
3499 >  else
3500 >    case $cross_compiling:$ac_tool_warned in
3501 > yes:)
3502 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
3503 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3504 > ac_tool_warned=yes ;;
3505 > esac
3506 >    CC=$ac_ct_CC
3507 >  fi
3508   fi
3509  
2548 – fi
3510  
3511 + test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
3512 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3513 + as_fn_error $? "no acceptable C compiler found in \$PATH
3514 + See \`config.log' for more details" "$LINENO" 5; }
3515  
3516 + # Provide some information about the compiler.
3517 + $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
3518 + set X $ac_compile
3519 + ac_compiler=$2
3520 + for ac_option in --version -v -V -qversion; do
3521 +  { { ac_try="$ac_compiler $ac_option >&5"
3522 + case "(($ac_try" in
3523 +  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3524 +  *) ac_try_echo=$ac_try;;
3525 + esac
3526 + eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
3527 + $as_echo "$ac_try_echo"; } >&5
3528 +  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
3529 +  ac_status=$?
3530 +  if test -s conftest.err; then
3531 +    sed '10a\
3532 + ... rest of stderr output deleted ...
3533 +         10q' conftest.err >conftest.er1
3534 +    cat conftest.er1 >&5
3535 +  fi
3536 +  rm -f conftest.er1 conftest.err
3537 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
3538 +  test $ac_status = 0; }
3539 + done
3540  
3541 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
3542 + $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3543 + if ${ac_cv_c_compiler_gnu+:} false; then :
3544 +  $as_echo_n "(cached) " >&6
3545 + else
3546 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3547 + /* end confdefs.h.  */
3548  
3549 < # Check whether --with-mpi was given.
3550 < if test "${with_mpi+set}" = set; then
3551 <  withval=$with_mpi;
3549 > int
3550 > main ()
3551 > {
3552 > #ifndef __GNUC__
3553 >       choke me
3554 > #endif
3555 >
3556 >  ;
3557 >  return 0;
3558 > }
3559 > _ACEOF
3560 > if ac_fn_c_try_compile "$LINENO"; then :
3561 >  ac_compiler_gnu=yes
3562   else
3563 <  with_mpi="auto"
3563 >  ac_compiler_gnu=no
3564   fi
3565 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3566 + ac_cv_c_compiler_gnu=$ac_compiler_gnu
3567  
3568 < if test "x$with_mpi" != "xno"; then
3568 > fi
3569 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
3570 > $as_echo "$ac_cv_c_compiler_gnu" >&6; }
3571 > if test $ac_compiler_gnu = yes; then
3572 >  GCC=yes
3573 > else
3574 >  GCC=
3575 > fi
3576 > ac_test_CFLAGS=${CFLAGS+set}
3577 > ac_save_CFLAGS=$CFLAGS
3578 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
3579 > $as_echo_n "checking whether $CC accepts -g... " >&6; }
3580 > if ${ac_cv_prog_cc_g+:} false; then :
3581 >  $as_echo_n "(cached) " >&6
3582 > else
3583 >  ac_save_c_werror_flag=$ac_c_werror_flag
3584 >   ac_c_werror_flag=yes
3585 >   ac_cv_prog_cc_g=no
3586 >   CFLAGS="-g"
3587 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3588 > /* end confdefs.h.  */
3589  
3590 + int
3591 + main ()
3592 + {
3593  
3594 < for ac_prog in $CC openmpicc mpicc
3595 < do
3596 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3597 < set dummy $ac_prog; ac_word=$2
3598 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3599 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2569 < if test "${ac_cv_prog_acx_mpi_mpicc+set}" = set; then
2570 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3594 >  ;
3595 >  return 0;
3596 > }
3597 > _ACEOF
3598 > if ac_fn_c_try_compile "$LINENO"; then :
3599 >  ac_cv_prog_cc_g=yes
3600   else
3601 <  if test -n "$acx_mpi_mpicc"; then
3602 <  ac_cv_prog_acx_mpi_mpicc="$acx_mpi_mpicc" # Let the user override the test.
3601 >  CFLAGS=""
3602 >      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3603 > /* end confdefs.h.  */
3604 >
3605 > int
3606 > main ()
3607 > {
3608 >
3609 >  ;
3610 >  return 0;
3611 > }
3612 > _ACEOF
3613 > if ac_fn_c_try_compile "$LINENO"; then :
3614 >
3615   else
3616 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3617 < for as_dir in $PATH
3618 < do
3619 <  IFS=$as_save_IFS
2579 <  test -z "$as_dir" && as_dir=.
2580 <  for ac_exec_ext in '' $ac_executable_extensions; do
2581 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2582 <    ac_cv_prog_acx_mpi_mpicc="$ac_prog"
2583 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2584 <    break 2
2585 <  fi
2586 < done
2587 < done
2588 < IFS=$as_save_IFS
3616 >  ac_c_werror_flag=$ac_save_c_werror_flag
3617 >         CFLAGS="-g"
3618 >         cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3619 > /* end confdefs.h.  */
3620  
3621 + int
3622 + main ()
3623 + {
3624 +
3625 +  ;
3626 +  return 0;
3627 + }
3628 + _ACEOF
3629 + if ac_fn_c_try_compile "$LINENO"; then :
3630 +  ac_cv_prog_cc_g=yes
3631   fi
3632 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3633   fi
3634 < acx_mpi_mpicc=$ac_cv_prog_acx_mpi_mpicc
3635 < if test -n "$acx_mpi_mpicc"; then
3636 <  { echo "$as_me:$LINENO: result: $acx_mpi_mpicc" >&5
3637 < echo "${ECHO_T}$acx_mpi_mpicc" >&6; }
3634 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3635 > fi
3636 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3637 >   ac_c_werror_flag=$ac_save_c_werror_flag
3638 > fi
3639 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
3640 > $as_echo "$ac_cv_prog_cc_g" >&6; }
3641 > if test "$ac_test_CFLAGS" = set; then
3642 >  CFLAGS=$ac_save_CFLAGS
3643 > elif test $ac_cv_prog_cc_g = yes; then
3644 >  if test "$GCC" = yes; then
3645 >    CFLAGS="-g -O2"
3646 >  else
3647 >    CFLAGS="-g"
3648 >  fi
3649   else
3650 <  { echo "$as_me:$LINENO: result: no" >&5
3651 < echo "${ECHO_T}no" >&6; }
3650 >  if test "$GCC" = yes; then
3651 >    CFLAGS="-O2"
3652 >  else
3653 >    CFLAGS=
3654 >  fi
3655   fi
3656 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
3657 + $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
3658 + if ${ac_cv_prog_cc_c89+:} false; then :
3659 +  $as_echo_n "(cached) " >&6
3660 + else
3661 +  ac_cv_prog_cc_c89=no
3662 + ac_save_CC=$CC
3663 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3664 + /* end confdefs.h.  */
3665 + #include <stdarg.h>
3666 + #include <stdio.h>
3667 + #include <sys/types.h>
3668 + #include <sys/stat.h>
3669 + /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3670 + struct buf { int x; };
3671 + FILE * (*rcsopen) (struct buf *, struct stat *, int);
3672 + static char *e (p, i)
3673 +     char **p;
3674 +     int i;
3675 + {
3676 +  return p[i];
3677 + }
3678 + static char *f (char * (*g) (char **, int), char **p, ...)
3679 + {
3680 +  char *s;
3681 +  va_list v;
3682 +  va_start (v,p);
3683 +  s = g (p, va_arg (v,int));
3684 +  va_end (v);
3685 +  return s;
3686 + }
3687  
3688 + /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3689 +   function prototypes and stuff, but not '\xHH' hex character constants.
3690 +   These don't provoke an error unfortunately, instead are silently treated
3691 +   as 'x'.  The following induces an error, until -std is added to get
3692 +   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3693 +   array size at least.  It's necessary to write '\x00'==0 to get something
3694 +   that's true only with -std.  */
3695 + int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3696  
3697 <  test -n "$acx_mpi_mpicc" && break
3698 < done
3699 < test -n "$acx_mpi_mpicc" || acx_mpi_mpicc="no"
3697 > /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
3698 >   inside strings and character constants.  */
3699 > #define FOO(x) 'x'
3700 > int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
3701  
3702 < if test $acx_mpi_mpicc != no; then
3703 <
3704 <  # Extract the first word of "$acx_mpi_mpicc", so it can be a program name with args.
3705 < set dummy $acx_mpi_mpicc; ac_word=$2
3706 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3707 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3708 < if test "${ac_cv_path_acx_mpi_mpicc_path+set}" = set; then
3709 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3710 < else
3711 <  case $acx_mpi_mpicc_path in
3712 <  [\\/]* | ?:[\\/]*)
3713 <  ac_cv_path_acx_mpi_mpicc_path="$acx_mpi_mpicc_path" # Let the user override the test with a path.
3714 <  ;;
3715 <  *)
3716 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3717 < for as_dir in $PATH
3702 > int test (int i, double x);
3703 > struct s1 {int (*f) (int a);};
3704 > struct s2 {int (*f) (double a);};
3705 > int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3706 > int argc;
3707 > char **argv;
3708 > int
3709 > main ()
3710 > {
3711 > return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3712 >  ;
3713 >  return 0;
3714 > }
3715 > _ACEOF
3716 > for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
3717 >        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3718   do
3719 <  IFS=$as_save_IFS
3720 <  test -z "$as_dir" && as_dir=.
3721 <  for ac_exec_ext in '' $ac_executable_extensions; do
3722 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3723 <    ac_cv_path_acx_mpi_mpicc_path="$as_dir/$ac_word$ac_exec_ext"
3724 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2629 <    break 2
2630 <  fi
3719 >  CC="$ac_save_CC $ac_arg"
3720 >  if ac_fn_c_try_compile "$LINENO"; then :
3721 >  ac_cv_prog_cc_c89=$ac_arg
3722 > fi
3723 > rm -f core conftest.err conftest.$ac_objext
3724 >  test "x$ac_cv_prog_cc_c89" != "xno" && break
3725   done
3726 < done
3727 < IFS=$as_save_IFS
3726 > rm -f conftest.$ac_ext
3727 > CC=$ac_save_CC
3728  
2635 –  test -z "$ac_cv_path_acx_mpi_mpicc_path" && ac_cv_path_acx_mpi_mpicc_path="no"
2636 –  ;;
2637 – esac
3729   fi
3730 < acx_mpi_mpicc_path=$ac_cv_path_acx_mpi_mpicc_path
3731 < if test -n "$acx_mpi_mpicc_path"; then
3732 <  { echo "$as_me:$LINENO: result: $acx_mpi_mpicc_path" >&5
3733 < echo "${ECHO_T}$acx_mpi_mpicc_path" >&6; }
3734 < else
3735 <  { echo "$as_me:$LINENO: result: no" >&5
3736 < echo "${ECHO_T}no" >&6; }
3730 > # AC_CACHE_VAL
3731 > case "x$ac_cv_prog_cc_c89" in
3732 >  x)
3733 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
3734 > $as_echo "none needed" >&6; } ;;
3735 >  xno)
3736 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
3737 > $as_echo "unsupported" >&6; } ;;
3738 >  *)
3739 >    CC="$CC $ac_cv_prog_cc_c89"
3740 >    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
3741 > $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
3742 > esac
3743 > if test "x$ac_cv_prog_cc_c89" != xno; then :
3744 >
3745   fi
3746  
3747 + ac_ext=c
3748 + ac_cpp='$CPP $CPPFLAGS'
3749 + ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3750 + ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3751 + ac_compiler_gnu=$ac_cv_c_compiler_gnu
3752  
3753 +
3754 + save_CXX=$CXX
3755 + save_CC=$CC
3756 + save_LIBS=$LIBS
3757 +
3758 + ac_ext=cpp
3759 + ac_cpp='$CXXCPP $CPPFLAGS'
3760 + ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3761 + ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3762 + ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3763 +
3764 +
3765 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lc" >&5
3766 + $as_echo_n "checking for dlopen in -lc... " >&6; }
3767 + if ${ac_cv_lib_c_dlopen+:} false; then :
3768 +  $as_echo_n "(cached) " >&6
3769 + else
3770 +  ac_check_lib_save_LIBS=$LIBS
3771 + LIBS="-lc  $LIBS"
3772 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3773 + /* end confdefs.h.  */
3774 +
3775 + /* Override any GCC internal prototype to avoid an error.
3776 +   Use char because int might match the return type of a GCC
3777 +   builtin and then its argument prototype would still apply.  */
3778 + #ifdef __cplusplus
3779 + extern "C"
3780 + #endif
3781 + char dlopen ();
3782 + int
3783 + main ()
3784 + {
3785 + return dlopen ();
3786 +  ;
3787 +  return 0;
3788 + }
3789 + _ACEOF
3790 + if ac_fn_cxx_try_link "$LINENO"; then :
3791 +  ac_cv_lib_c_dlopen=yes
3792 + else
3793 +  ac_cv_lib_c_dlopen=no
3794   fi
3795 + rm -f core conftest.err conftest.$ac_objext \
3796 +    conftest$ac_exeext conftest.$ac_ext
3797 + LIBS=$ac_check_lib_save_LIBS
3798 + fi
3799 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_c_dlopen" >&5
3800 + $as_echo "$ac_cv_lib_c_dlopen" >&6; }
3801 + if test "x$ac_cv_lib_c_dlopen" = xyes; then :
3802 +  LIBDL=""
3803 + else
3804 +  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
3805 + $as_echo_n "checking for dlopen in -ldl... " >&6; }
3806 + if ${ac_cv_lib_dl_dlopen+:} false; then :
3807 +  $as_echo_n "(cached) " >&6
3808 + else
3809 +  ac_check_lib_save_LIBS=$LIBS
3810 + LIBS="-ldl  $LIBS"
3811 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3812 + /* end confdefs.h.  */
3813  
3814 < for ac_prog in $FC openmpif90 mpif90
3814 > /* Override any GCC internal prototype to avoid an error.
3815 >   Use char because int might match the return type of a GCC
3816 >   builtin and then its argument prototype would still apply.  */
3817 > #ifdef __cplusplus
3818 > extern "C"
3819 > #endif
3820 > char dlopen ();
3821 > int
3822 > main ()
3823 > {
3824 > return dlopen ();
3825 >  ;
3826 >  return 0;
3827 > }
3828 > _ACEOF
3829 > if ac_fn_cxx_try_link "$LINENO"; then :
3830 >  ac_cv_lib_dl_dlopen=yes
3831 > else
3832 >  ac_cv_lib_dl_dlopen=no
3833 > fi
3834 > rm -f core conftest.err conftest.$ac_objext \
3835 >    conftest$ac_exeext conftest.$ac_ext
3836 > LIBS=$ac_check_lib_save_LIBS
3837 > fi
3838 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
3839 > $as_echo "$ac_cv_lib_dl_dlopen" >&6; }
3840 > if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
3841 >  LIBDL="-ldl"
3842 > fi
3843 >
3844 > fi
3845 >
3846 >
3847 >
3848 >
3849 >
3850 >
3851 >
3852 >        for ac_prog in openmpicxx openmpiCC openmpic++ mpic++ mpicxx mpiCC hcp mpxlC_r mpxlC mpCC cmpic++
3853   do
3854    # Extract the first word of "$ac_prog", so it can be a program name with args.
3855   set dummy $ac_prog; ac_word=$2
3856 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3857 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3858 < if test "${ac_cv_prog_acx_mpi_mpif90+set}" = set; then
3859 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3856 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
3857 > $as_echo_n "checking for $ac_word... " >&6; }
3858 > if ${ac_cv_prog_MPICXX+:} false; then :
3859 >  $as_echo_n "(cached) " >&6
3860   else
3861 <  if test -n "$acx_mpi_mpif90"; then
3862 <  ac_cv_prog_acx_mpi_mpif90="$acx_mpi_mpif90" # Let the user override the test.
3861 >  if test -n "$MPICXX"; then
3862 >  ac_cv_prog_MPICXX="$MPICXX" # Let the user override the test.
3863   else
3864   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3865   for as_dir in $PATH
3866   do
3867    IFS=$as_save_IFS
3868    test -z "$as_dir" && as_dir=.
3869 <  for ac_exec_ext in '' $ac_executable_extensions; do
3869 >    for ac_exec_ext in '' $ac_executable_extensions; do
3870    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3871 <    ac_cv_prog_acx_mpi_mpif90="$ac_prog"
3872 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3871 >    ac_cv_prog_MPICXX="$ac_prog"
3872 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
3873      break 2
3874    fi
3875   done
3876 < done
3876 >  done
3877   IFS=$as_save_IFS
3878  
3879   fi
3880   fi
3881 < acx_mpi_mpif90=$ac_cv_prog_acx_mpi_mpif90
3882 < if test -n "$acx_mpi_mpif90"; then
3883 <  { echo "$as_me:$LINENO: result: $acx_mpi_mpif90" >&5
3884 < echo "${ECHO_T}$acx_mpi_mpif90" >&6; }
3881 > MPICXX=$ac_cv_prog_MPICXX
3882 > if test -n "$MPICXX"; then
3883 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICXX" >&5
3884 > $as_echo "$MPICXX" >&6; }
3885   else
3886 <  { echo "$as_me:$LINENO: result: no" >&5
3887 < echo "${ECHO_T}no" >&6; }
3886 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
3887 > $as_echo "no" >&6; }
3888   fi
3889  
3890  
3891 <  test -n "$acx_mpi_mpif90" && break
3891 >  test -n "$MPICXX" && break
3892   done
3893 < test -n "$acx_mpi_mpif90" || acx_mpi_mpif90="no"
3893 > test -n "$MPICXX" || MPICXX="$CXX"
3894  
3895 < if test $acx_mpi_mpif90 != no; then
3895 >        ax_mpi_save_CXX="$CXX"
3896 >        CXX="$MPICXX"
3897  
3898 <  # Extract the first word of "$acx_mpi_mpif90", so it can be a program name with args.
3899 < set dummy $acx_mpi_mpif90; ac_word=$2
3900 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3901 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3902 < if test "${ac_cv_path_acx_mpi_mpif90_path+set}" = set; then
3903 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3898 >
3899 >
3900 > if test x = x"$MPILIBS"; then
3901 >        ac_fn_cxx_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
3902 > if test "x$ac_cv_func_MPI_Init" = xyes; then :
3903 >  MPILIBS=" "
3904 > fi
3905 >
3906 > fi
3907 >
3908 > if test x = x"$MPILIBS"; then
3909 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
3910 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
3911 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
3912 >  $as_echo_n "(cached) " >&6
3913   else
3914 <  case $acx_mpi_mpif90_path in
3915 <  [\\/]* | ?:[\\/]*)
3916 <  ac_cv_path_acx_mpi_mpif90_path="$acx_mpi_mpif90_path" # Let the user override the test with a path.
3917 <  ;;
2707 <  *)
2708 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2709 < for as_dir in $PATH
2710 < do
2711 <  IFS=$as_save_IFS
2712 <  test -z "$as_dir" && as_dir=.
2713 <  for ac_exec_ext in '' $ac_executable_extensions; do
2714 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2715 <    ac_cv_path_acx_mpi_mpif90_path="$as_dir/$ac_word$ac_exec_ext"
2716 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2717 <    break 2
2718 <  fi
2719 < done
2720 < done
2721 < IFS=$as_save_IFS
3914 >  ac_check_lib_save_LIBS=$LIBS
3915 > LIBS="-lmpi  $LIBS"
3916 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3917 > /* end confdefs.h.  */
3918  
3919 <  test -z "$ac_cv_path_acx_mpi_mpif90_path" && ac_cv_path_acx_mpi_mpif90_path="no"
3920 <  ;;
3921 < esac
3919 > /* Override any GCC internal prototype to avoid an error.
3920 >   Use char because int might match the return type of a GCC
3921 >   builtin and then its argument prototype would still apply.  */
3922 > #ifdef __cplusplus
3923 > extern "C"
3924 > #endif
3925 > char MPI_Init ();
3926 > int
3927 > main ()
3928 > {
3929 > return MPI_Init ();
3930 >  ;
3931 >  return 0;
3932 > }
3933 > _ACEOF
3934 > if ac_fn_cxx_try_link "$LINENO"; then :
3935 >  ac_cv_lib_mpi_MPI_Init=yes
3936 > else
3937 >  ac_cv_lib_mpi_MPI_Init=no
3938   fi
3939 < acx_mpi_mpif90_path=$ac_cv_path_acx_mpi_mpif90_path
3940 < if test -n "$acx_mpi_mpif90_path"; then
3941 <  { echo "$as_me:$LINENO: result: $acx_mpi_mpif90_path" >&5
3942 < echo "${ECHO_T}$acx_mpi_mpif90_path" >&6; }
3939 > rm -f core conftest.err conftest.$ac_objext \
3940 >    conftest$ac_exeext conftest.$ac_ext
3941 > LIBS=$ac_check_lib_save_LIBS
3942 > fi
3943 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
3944 > $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
3945 > if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
3946 >  MPILIBS="-lmpi"
3947 > fi
3948 >
3949 > fi
3950 > if test x = x"$MPILIBS"; then
3951 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
3952 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
3953 > if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
3954 >  $as_echo_n "(cached) " >&6
3955   else
3956 <  { echo "$as_me:$LINENO: result: no" >&5
3957 < echo "${ECHO_T}no" >&6; }
3956 >  ac_check_lib_save_LIBS=$LIBS
3957 > LIBS="-lmpich  $LIBS"
3958 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3959 > /* end confdefs.h.  */
3960 >
3961 > /* Override any GCC internal prototype to avoid an error.
3962 >   Use char because int might match the return type of a GCC
3963 >   builtin and then its argument prototype would still apply.  */
3964 > #ifdef __cplusplus
3965 > extern "C"
3966 > #endif
3967 > char MPI_Init ();
3968 > int
3969 > main ()
3970 > {
3971 > return MPI_Init ();
3972 >  ;
3973 >  return 0;
3974 > }
3975 > _ACEOF
3976 > if ac_fn_cxx_try_link "$LINENO"; then :
3977 >  ac_cv_lib_mpich_MPI_Init=yes
3978 > else
3979 >  ac_cv_lib_mpich_MPI_Init=no
3980   fi
3981 + rm -f core conftest.err conftest.$ac_objext \
3982 +    conftest$ac_exeext conftest.$ac_ext
3983 + LIBS=$ac_check_lib_save_LIBS
3984 + fi
3985 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
3986 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
3987 + if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
3988 +  MPILIBS="-lmpich"
3989 + fi
3990  
3991 + fi
3992  
3993 + if test x != x"$MPILIBS"; then
3994 +        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
3995 + $as_echo_n "checking for mpi.h... " >&6; }
3996 +        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
3997 + /* end confdefs.h.  */
3998 + #include <mpi.h>
3999 + int
4000 + main ()
4001 + {
4002 +
4003 +  ;
4004 +  return 0;
4005 + }
4006 + _ACEOF
4007 + if ac_fn_cxx_try_compile "$LINENO"; then :
4008 +  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4009 + $as_echo "yes" >&6; }
4010 + else
4011 +  MPILIBS=""
4012 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4013 + $as_echo "no" >&6; }
4014   fi
4015 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4016 + fi
4017  
4018 < for ac_prog in $CXX openmpicxx openmpiCC openmpic++ mpicxx mpiCC mpic++
4018 > CXX="$ax_mpi_save_CXX"
4019 >
4020 >
4021 >
4022 > # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4023 > if test x = x"$MPILIBS"; then
4024 >        USE_MPI="no"
4025 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&5
4026 > $as_echo "$as_me: WARNING: No suitable C++ MPI implementation found. openmd_MPI will not be built." >&2;}
4027 >        :
4028 > else
4029 >        USE_MPI="yes"
4030 >        :
4031 > fi
4032 >
4033 >
4034 > if test $USE_MPI != no; then :
4035 >
4036 > ac_ext=c
4037 > ac_cpp='$CPP $CPPFLAGS'
4038 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4039 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4040 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4041 >
4042 >
4043 >
4044 >
4045 >
4046 >
4047 >        for ac_prog in openmpicc mpicc hcc mpxlc_r mpxlc mpcc cmpicc
4048   do
4049    # Extract the first word of "$ac_prog", so it can be a program name with args.
4050   set dummy $ac_prog; ac_word=$2
4051 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4052 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4053 < if test "${ac_cv_prog_acx_mpi_mpicxx+set}" = set; then
4054 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4051 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4052 > $as_echo_n "checking for $ac_word... " >&6; }
4053 > if ${ac_cv_prog_MPICC+:} false; then :
4054 >  $as_echo_n "(cached) " >&6
4055   else
4056 <  if test -n "$acx_mpi_mpicxx"; then
4057 <  ac_cv_prog_acx_mpi_mpicxx="$acx_mpi_mpicxx" # Let the user override the test.
4056 >  if test -n "$MPICC"; then
4057 >  ac_cv_prog_MPICC="$MPICC" # Let the user override the test.
4058   else
4059   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4060   for as_dir in $PATH
4061   do
4062    IFS=$as_save_IFS
4063    test -z "$as_dir" && as_dir=.
4064 <  for ac_exec_ext in '' $ac_executable_extensions; do
4064 >    for ac_exec_ext in '' $ac_executable_extensions; do
4065    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4066 <    ac_cv_prog_acx_mpi_mpicxx="$ac_prog"
4067 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4066 >    ac_cv_prog_MPICC="$ac_prog"
4067 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4068      break 2
4069    fi
4070   done
4071 < done
4071 >  done
4072   IFS=$as_save_IFS
4073  
4074   fi
4075   fi
4076 < acx_mpi_mpicxx=$ac_cv_prog_acx_mpi_mpicxx
4077 < if test -n "$acx_mpi_mpicxx"; then
4078 <  { echo "$as_me:$LINENO: result: $acx_mpi_mpicxx" >&5
4079 < echo "${ECHO_T}$acx_mpi_mpicxx" >&6; }
4076 > MPICC=$ac_cv_prog_MPICC
4077 > if test -n "$MPICC"; then
4078 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MPICC" >&5
4079 > $as_echo "$MPICC" >&6; }
4080   else
4081 <  { echo "$as_me:$LINENO: result: no" >&5
4082 < echo "${ECHO_T}no" >&6; }
4081 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4082 > $as_echo "no" >&6; }
4083   fi
4084  
4085  
4086 <  test -n "$acx_mpi_mpicxx" && break
4086 >  test -n "$MPICC" && break
4087   done
4088 < test -n "$acx_mpi_mpicxx" || acx_mpi_mpicxx="no"
4088 > test -n "$MPICC" || MPICC="$CC"
4089  
4090 < if test $acx_mpi_mpicxx != no; then
4090 >        ax_mpi_save_CC="$CC"
4091 >        CC="$MPICC"
4092  
2784 –  # Extract the first word of "$acx_mpi_mpicxx", so it can be a program name with args.
2785 – set dummy $acx_mpi_mpicxx; ac_word=$2
2786 – { echo "$as_me:$LINENO: checking for $ac_word" >&5
2787 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
2788 – if test "${ac_cv_path_acx_mpi_mpicxx_path+set}" = set; then
2789 –  echo $ECHO_N "(cached) $ECHO_C" >&6
2790 – else
2791 –  case $acx_mpi_mpicxx_path in
2792 –  [\\/]* | ?:[\\/]*)
2793 –  ac_cv_path_acx_mpi_mpicxx_path="$acx_mpi_mpicxx_path" # Let the user override the test with a path.
2794 –  ;;
2795 –  *)
2796 –  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2797 – for as_dir in $PATH
2798 – do
2799 –  IFS=$as_save_IFS
2800 –  test -z "$as_dir" && as_dir=.
2801 –  for ac_exec_ext in '' $ac_executable_extensions; do
2802 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2803 –    ac_cv_path_acx_mpi_mpicxx_path="$as_dir/$ac_word$ac_exec_ext"
2804 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2805 –    break 2
2806 –  fi
2807 – done
2808 – done
2809 – IFS=$as_save_IFS
4093  
4094 <  test -z "$ac_cv_path_acx_mpi_mpicxx_path" && ac_cv_path_acx_mpi_mpicxx_path="no"
4095 <  ;;
4096 < esac
4094 >
4095 > if test x = x"$MPILIBS"; then
4096 >        ac_fn_c_check_func "$LINENO" "MPI_Init" "ac_cv_func_MPI_Init"
4097 > if test "x$ac_cv_func_MPI_Init" = xyes; then :
4098 >  MPILIBS=" "
4099   fi
2815 – acx_mpi_mpicxx_path=$ac_cv_path_acx_mpi_mpicxx_path
2816 – if test -n "$acx_mpi_mpicxx_path"; then
2817 –  { echo "$as_me:$LINENO: result: $acx_mpi_mpicxx_path" >&5
2818 – echo "${ECHO_T}$acx_mpi_mpicxx_path" >&6; }
2819 – else
2820 –  { echo "$as_me:$LINENO: result: no" >&5
2821 – echo "${ECHO_T}no" >&6; }
2822 – fi
4100  
2824 –
4101   fi
4102  
4103 < if test $acx_mpi_mpicc = no; then
4104 <
4105 <  if test $acx_mpi_mpicxx = no; then
4106 <
4107 <    acx_mpi_compiler=no
2832 <
4103 > if test x = x"$MPILIBS"; then
4104 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpi" >&5
4105 > $as_echo_n "checking for MPI_Init in -lmpi... " >&6; }
4106 > if ${ac_cv_lib_mpi_MPI_Init+:} false; then :
4107 >  $as_echo_n "(cached) " >&6
4108   else
4109 +  ac_check_lib_save_LIBS=$LIBS
4110 + LIBS="-lmpi  $LIBS"
4111 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4112 + /* end confdefs.h.  */
4113  
4114 <    acx_mpi_compiler=$acx_mpi_mpicxx
4115 <    acx_mpi_compiler_path=$acx_mpi_mpicxx_path
4114 > /* Override any GCC internal prototype to avoid an error.
4115 >   Use char because int might match the return type of a GCC
4116 >   builtin and then its argument prototype would still apply.  */
4117 > #ifdef __cplusplus
4118 > extern "C"
4119 > #endif
4120 > char MPI_Init ();
4121 > int
4122 > main ()
4123 > {
4124 > return MPI_Init ();
4125 >  ;
4126 >  return 0;
4127 > }
4128 > _ACEOF
4129 > if ac_fn_c_try_link "$LINENO"; then :
4130 >  ac_cv_lib_mpi_MPI_Init=yes
4131 > else
4132 >  ac_cv_lib_mpi_MPI_Init=no
4133   fi
4134 + rm -f core conftest.err conftest.$ac_objext \
4135 +    conftest$ac_exeext conftest.$ac_ext
4136 + LIBS=$ac_check_lib_save_LIBS
4137 + fi
4138 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpi_MPI_Init" >&5
4139 + $as_echo "$ac_cv_lib_mpi_MPI_Init" >&6; }
4140 + if test "x$ac_cv_lib_mpi_MPI_Init" = xyes; then :
4141 +  MPILIBS="-lmpi"
4142 + fi
4143  
4144 <
4144 > fi
4145 > if test x = x"$MPILIBS"; then
4146 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MPI_Init in -lmpich" >&5
4147 > $as_echo_n "checking for MPI_Init in -lmpich... " >&6; }
4148 > if ${ac_cv_lib_mpich_MPI_Init+:} false; then :
4149 >  $as_echo_n "(cached) " >&6
4150   else
4151 +  ac_check_lib_save_LIBS=$LIBS
4152 + LIBS="-lmpich  $LIBS"
4153 + cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4154 + /* end confdefs.h.  */
4155  
4156 <  if test $acx_mpi_mpicxx = no; then
4157 <
4158 <    acx_mpi_compiler=$acx_mpi_mpicc
4159 <    acx_mpi_compiler_path=$acx_mpi_mpicc_path
4160 <
4156 > /* Override any GCC internal prototype to avoid an error.
4157 >   Use char because int might match the return type of a GCC
4158 >   builtin and then its argument prototype would still apply.  */
4159 > #ifdef __cplusplus
4160 > extern "C"
4161 > #endif
4162 > char MPI_Init ();
4163 > int
4164 > main ()
4165 > {
4166 > return MPI_Init ();
4167 >  ;
4168 >  return 0;
4169 > }
4170 > _ACEOF
4171 > if ac_fn_c_try_link "$LINENO"; then :
4172 >  ac_cv_lib_mpich_MPI_Init=yes
4173   else
4174 +  ac_cv_lib_mpich_MPI_Init=no
4175 + fi
4176 + rm -f core conftest.err conftest.$ac_objext \
4177 +    conftest$ac_exeext conftest.$ac_ext
4178 + LIBS=$ac_check_lib_save_LIBS
4179 + fi
4180 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_mpich_MPI_Init" >&5
4181 + $as_echo "$ac_cv_lib_mpich_MPI_Init" >&6; }
4182 + if test "x$ac_cv_lib_mpich_MPI_Init" = xyes; then :
4183 +  MPILIBS="-lmpich"
4184 + fi
4185  
4186 <    { echo "$as_me:$LINENO: checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx" >&5
2850 < echo $ECHO_N "checking whether to use $acx_mpi_mpicc or $acx_mpi_mpicxx... $ECHO_C" >&6; }
2851 <    ac_ext=cpp
2852 < ac_cpp='$CXXCPP $CPPFLAGS'
2853 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2854 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2855 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
4186 > fi
4187  
4188 <    cat >conftest.$ac_ext <<_ACEOF
4189 < /* confdefs.h.  */
4190 < _ACEOF
4191 < cat confdefs.h >>conftest.$ac_ext
2861 < cat >>conftest.$ac_ext <<_ACEOF
4188 > if test x != x"$MPILIBS"; then
4189 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for mpi.h" >&5
4190 > $as_echo_n "checking for mpi.h... " >&6; }
4191 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4192   /* end confdefs.h.  */
2863 –
4193   #include <mpi.h>
2865 –
4194   int
4195   main ()
4196   {
4197  
2870 – MPI_Finalize();
2871 –
4198    ;
4199    return 0;
4200   }
4201   _ACEOF
4202 <    if { (ac_try="$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5"
4203 < case "(($ac_try" in
4204 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4205 <  *) ac_try_echo=$ac_try;;
4206 < esac
4207 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4208 <  (eval "$acx_mpi_mpicxx_path -c conftest.$ac_ext >&5") 2>conftest.er1
4209 <  ac_status=$?
4210 <  grep -v '^ *+' conftest.er1 >conftest.err
4211 <  rm -f conftest.er1
2886 <  cat conftest.err >&5
2887 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2888 <  (exit $ac_status); } && {
2889 <         test -z "$ac_cxx_werror_flag" ||
2890 <         test ! -s conftest.err
2891 <       } && test -s conftest.$ac_objext; then
4202 > if ac_fn_c_try_compile "$LINENO"; then :
4203 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4204 > $as_echo "yes" >&6; }
4205 > else
4206 >  MPILIBS=""
4207 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4208 > $as_echo "no" >&6; }
4209 > fi
4210 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4211 > fi
4212  
4213 <      acx_mpi_compiler=$acx_mpi_mpicxx
2894 <      acx_mpi_compiler_path=$acx_mpi_mpicxx_path
4213 > CC="$ax_mpi_save_CC"
4214  
2896 – else
4215  
4216 <      acx_mpi_compiler=$acx_mpi_mpicc
4217 <      acx_mpi_compiler_path=$acx_mpi_mpicc_path
4216 >
4217 > # Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
4218 > if test x = x"$MPILIBS"; then
4219 >        USE_MPI="no"
4220 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&5
4221 > $as_echo "$as_me: WARNING: No suitable C MPI implementation found. openmd_MPI will not be built." >&2;}
4222 >        :
4223 > else
4224 >        USE_MPI="yes"
4225 >        :
4226   fi
4227  
2902 –    ac_ext=c
2903 – ac_cpp='$CPP $CPPFLAGS'
2904 – ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2905 – ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2906 – ac_compiler_gnu=$ac_cv_c_compiler_gnu
4228  
2908 –    { echo "$as_me:$LINENO: result: $acx_mpi_compiler" >&5
2909 – echo "${ECHO_T}$acx_mpi_compiler" >&6; }
4229   fi
4230 + if test $USE_MPI != no; then :
4231  
4232 < fi
4232 >        CXX=$MPICXX
4233 >        CC=$MPICC
4234 >        LIBS="$MPILIBS $LIBS"
4235  
2914 – { echo "$as_me:$LINENO: checking whether mpif.h is usable" >&5
2915 – echo $ECHO_N "checking whether mpif.h is usable... $ECHO_C" >&6; }
2916 – ac_ext=${ac_fc_srcext-f}
2917 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
2918 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
2919 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
2920 –
2921 – ac_save_ext=$ac_ext
2922 – ac_ext=F90
2923 – rm -f conftest*
2924 – cat >conftest.$ac_ext <<EOF
2925 – program main
2926 –   include 'mpif.h'
2927 –   call MPI_Init
2928 – end
2929 – EOF
2930 – if $acx_mpi_mpif90_path -c conftest.$ac_ext > conftest.out 2>&1 ; then
2931 –        acx_mpi_f90_compiler=yes
2932 –        { echo "$as_me:$LINENO: result: yes" >&5
2933 – echo "${ECHO_T}yes" >&6; }
4236   else
4237 <        if test -s conftest.out ; then
4238 <                cat conftest.out >> config.log
4239 <        fi
4240 <        acx_mpi_f90_compiler=no
4241 <        { echo "$as_me:$LINENO: result: no! Check MPI fortran include paths" >&5
4242 < echo "${ECHO_T}no! Check MPI fortran include paths" >&6; }
4237 >
4238 >        CXX=$save_CXX
4239 >        CC=$save_CC
4240 >        LIBS=$save_LIBS
4241 >
4242 >
4243   fi
4244 < rm -f conftest*
4245 < ac_ext=$ac_save_ext
4244 >
4245 >
4246 > # Checks for programs.
4247   ac_ext=c
4248   ac_cpp='$CPP $CPPFLAGS'
4249   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4250   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4251   ac_compiler_gnu=$ac_cv_c_compiler_gnu
4252 <
4253 < if test $acx_mpi_compiler = no || test $acx_mpi_f90_compiler = no; then
4254 <
4255 < acx_cv_mpi_implementation=no
4252 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
4253 > $as_echo_n "checking how to run the C preprocessor... " >&6; }
4254 > # On Suns, sometimes $CPP names a directory.
4255 > if test -n "$CPP" && test -d "$CPP"; then
4256 >  CPP=
4257 > fi
4258 > if test -z "$CPP"; then
4259 >  if ${ac_cv_prog_CPP+:} false; then :
4260 >  $as_echo_n "(cached) " >&6
4261   else
4262 <  { echo "$as_me:$LINENO: checking for the MPI implementation flavor" >&5
4263 < echo $ECHO_N "checking for the MPI implementation flavor... $ECHO_C" >&6; }
4264 < if test "${acx_cv_mpi_implementation+set}" = set; then
4265 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4266 < else
4267 <  acx_cv_mpi_implementation=no
4268 < if { (ac_try="grep -q LAM $acx_mpi_compiler_path"
4269 < case "(($ac_try" in
4270 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4271 <  *) ac_try_echo=$ac_try;;
4272 < esac
4273 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4274 <  (eval "grep -q LAM $acx_mpi_compiler_path") 2>conftest.er1
4275 <  ac_status=$?
4276 <  grep -v '^ *+' conftest.er1 >conftest.err
4277 <  rm -f conftest.er1
4278 <  cat conftest.err >&5
4279 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4280 <  (exit $ac_status); }; then
4262 >      # Double quotes because CPP needs to be expanded
4263 >    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
4264 >    do
4265 >      ac_preproc_ok=false
4266 > for ac_c_preproc_warn_flag in '' yes
4267 > do
4268 >  # Use a header file that comes with gcc, so configuring glibc
4269 >  # with a fresh cross-compiler works.
4270 >  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4271 >  # <limits.h> exists even on freestanding compilers.
4272 >  # On the NeXT, cc -E runs the code through the compiler's parser,
4273 >  # not just through cpp. "Syntax error" is here to catch this case.
4274 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4275 > /* end confdefs.h.  */
4276 > #ifdef __STDC__
4277 > # include <limits.h>
4278 > #else
4279 > # include <assert.h>
4280 > #endif
4281 >                     Syntax error
4282 > _ACEOF
4283 > if ac_fn_c_try_cpp "$LINENO"; then :
4284  
2974 –  acx_cv_mpi_implementation=lammpi
2975 –
4285   else
4286 +  # Broken: fails on valid input.
4287 + continue
4288 + fi
4289 + rm -f conftest.err conftest.i conftest.$ac_ext
4290  
4291 <  if { (ac_try="grep -q showme $acx_mpi_compiler_path"
4292 < case "(($ac_try" in
4293 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4294 <  *) ac_try_echo=$ac_try;;
4295 < esac
4296 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4297 <  (eval "grep -q showme $acx_mpi_compiler_path") 2>conftest.er1
4298 <  ac_status=$?
4299 <  grep -v '^ *+' conftest.er1 >conftest.err
2987 <  rm -f conftest.er1
2988 <  cat conftest.err >&5
2989 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
2990 <  (exit $ac_status); }; then
2991 <
2992 <    acx_cv_mpi_implementation=openmpi
2993 <
4291 >  # OK, works on sane cases.  Now check whether nonexistent headers
4292 >  # can be detected and how.
4293 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4294 > /* end confdefs.h.  */
4295 > #include <ac_nonexistent.h>
4296 > _ACEOF
4297 > if ac_fn_c_try_cpp "$LINENO"; then :
4298 >  # Broken: success on invalid input.
4299 > continue
4300   else
4301 +  # Passes both tests.
4302 + ac_preproc_ok=:
4303 + break
4304 + fi
4305 + rm -f conftest.err conftest.i conftest.$ac_ext
4306  
4307 <    if { (ac_try="grep -q MPICH $acx_mpi_compiler_path"
4308 < case "(($ac_try" in
4309 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4310 <  *) ac_try_echo=$ac_try;;
4311 < esac
4312 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3002 <  (eval "grep -q MPICH $acx_mpi_compiler_path") 2>conftest.er1
3003 <  ac_status=$?
3004 <  grep -v '^ *+' conftest.er1 >conftest.err
3005 <  rm -f conftest.er1
3006 <  cat conftest.err >&5
3007 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3008 <  (exit $ac_status); }; then
4307 > done
4308 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4309 > rm -f conftest.i conftest.err conftest.$ac_ext
4310 > if $ac_preproc_ok; then :
4311 >  break
4312 > fi
4313  
4314 <      acx_cv_mpi_implementation=mpich
4314 >    done
4315 >    ac_cv_prog_CPP=$CPP
4316  
4317 + fi
4318 +  CPP=$ac_cv_prog_CPP
4319   else
4320 <  acx_cv_mpi_implementation=$with_mpi
4320 >  ac_cv_prog_CPP=$CPP
4321   fi
4322 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
4323 + $as_echo "$CPP" >&6; }
4324 + ac_preproc_ok=false
4325 + for ac_c_preproc_warn_flag in '' yes
4326 + do
4327 +  # Use a header file that comes with gcc, so configuring glibc
4328 +  # with a fresh cross-compiler works.
4329 +  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
4330 +  # <limits.h> exists even on freestanding compilers.
4331 +  # On the NeXT, cc -E runs the code through the compiler's parser,
4332 +  # not just through cpp. "Syntax error" is here to catch this case.
4333 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4334 + /* end confdefs.h.  */
4335 + #ifdef __STDC__
4336 + # include <limits.h>
4337 + #else
4338 + # include <assert.h>
4339 + #endif
4340 +                     Syntax error
4341 + _ACEOF
4342 + if ac_fn_c_try_cpp "$LINENO"; then :
4343  
4344 + else
4345 +  # Broken: fails on valid input.
4346 + continue
4347   fi
4348 + rm -f conftest.err conftest.i conftest.$ac_ext
4349  
4350 +  # OK, works on sane cases.  Now check whether nonexistent headers
4351 +  # can be detected and how.
4352 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
4353 + /* end confdefs.h.  */
4354 + #include <ac_nonexistent.h>
4355 + _ACEOF
4356 + if ac_fn_c_try_cpp "$LINENO"; then :
4357 +  # Broken: success on invalid input.
4358 + continue
4359 + else
4360 +  # Passes both tests.
4361 + ac_preproc_ok=:
4362 + break
4363   fi
4364 + rm -f conftest.err conftest.i conftest.$ac_ext
4365  
4366 < fi
4367 < { echo "$as_me:$LINENO: result: $acx_cv_mpi_implementation" >&5
4368 < echo "${ECHO_T}$acx_cv_mpi_implementation" >&6; }
4366 > done
4367 > # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
4368 > rm -f conftest.i conftest.err conftest.$ac_ext
4369 > if $ac_preproc_ok; then :
4370  
4371 + else
4372 +  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
4373 + $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
4374 + as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
4375 + See \`config.log' for more details" "$LINENO" 5; }
4376   fi
3025 – case $acx_cv_mpi_implementation in
3026 – (lammpi)
4377  
4378 < cat >>confdefs.h <<\_ACEOF
4379 < #define MPI_IS_LAMMPI 1
4380 < _ACEOF
4378 > ac_ext=c
4379 > ac_cpp='$CPP $CPPFLAGS'
4380 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4381 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4382 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
4383  
4384 <  ;;
4385 < (openmpi)
4386 <
4387 < cat >>confdefs.h <<\_ACEOF
3036 < #define MPI_IS_OPENMPI 1
3037 < _ACEOF
3038 <
3039 <  ;;
3040 < (mpich)
3041 <
3042 < cat >>confdefs.h <<\_ACEOF
3043 < #define MPI_IS_MPICH 1
3044 < _ACEOF
3045 <
3046 <  ;;
3047 < esac
3048 < if test $acx_cv_mpi_implementation = no; then
3049 <
3050 < acx_mpi_cflags=""
3051 < acx_mpi_libs=""
3052 < USE_MPI="no"
3053 <        { echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
3054 < echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
4384 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
4385 > $as_echo_n "checking for grep that handles long lines and -e... " >&6; }
4386 > if ${ac_cv_path_GREP+:} false; then :
4387 >  $as_echo_n "(cached) " >&6
4388   else
4389 <
4390 <
4391 < { echo "$as_me:$LINENO: checking how to compile MPI-C code" >&5
4392 < echo $ECHO_N "checking how to compile MPI-C code... $ECHO_C" >&6; }
4393 < if test "${acx_mpi_cflags+set}" = set; then
4394 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4395 < else
4396 <
4397 < case $acx_cv_mpi_implementation in
4398 <  (lammpi)
4399 <    cfo="--showme:compile"
4400 <    ;;
4401 <  (openmpi)
4402 <    cfo="--showme:compile"
4403 <    ;;
4404 <  (mpich)
4405 <    case "$acx_mpi_compiler_path" in
4406 <      (*mpiCC)
4407 <        sc_cv_cn="-CC="
4408 <        ;;
4409 <      (*mpicxx)
4410 <        sc_cv_cn="-cxx="
4411 <        ;;
4412 <      (*mpicc)
4413 <        sc_cv_cn="-cc="
4414 <        ;;
4415 <      (*)
4416 <        sc_cv_cn=""
4417 <        ;;
4418 <    esac
4419 <    cfo="-compile_info $sc_cv_cn"
4420 <    ;;
4421 < esac
4422 < echo "$as_me:$LINENO: mpi_pre_cflags=\"\`$acx_mpi_compiler_path $cfo || echo ' no'\`\"" >&5
4423 < mpi_pre_cflags="`$acx_mpi_compiler_path $cfo 2>conftest.er1 || echo ' no'`"
4424 < grep -v '^ *+' conftest.er1 >conftest.err
3092 < rm -f conftest.er1
3093 < cat conftest.err >&5
3094 < echo "$as_me:$LINENO: mpi_pre_cflags = $mpi_pre_cflags" >&5
3095 < case "$mpi_pre_cflags" in
3096 <  (*no)
3097 <    acx_mpi_cflags=no
3098 <    acx_mpi_cflags="no"
3099 <    ;;
3100 <  (*)
3101 <    acx_mpi_tmp_mode="normal"
3102 <  acx_mpi_tmp_prefix=""
3103 <  eval "acx_mpi_cflags=\"\""
3104 <  for acx_mpi_tmp in $mpi_pre_cflags; do
3105 <    case "$acx_mpi_tmp_mode" in
3106 <      (normal)
3107 <        case "$acx_mpi_tmp" in
3108 <          (-I|-D)
3109 <            acx_mpi_tmp_prefix="$acx_mpi_tmp"
3110 <            acx_mpi_tmp_mode="accept"
3111 <            ;;
3112 <          (-I*|-D*)
3113 <            eval "acx_mpi_cflags=\"`eval echo '${'\\acx_mpi_cflags'}'` \$acx_mpi_tmp\""
3114 <            ;;
3115 <          (-L|-l)
3116 <            acx_mpi_tmp_mode="skip"
3117 <            ;;
3118 <          (*)
3119 <            ;;
3120 <        esac
3121 <        ;;
3122 <      (accept)
3123 <        eval "acx_mpi_cflags=\"`eval echo '${'\\acx_mpi_cflags'}'` \$acx_mpi_tmp_prefix \$acx_mpi_tmp\""
3124 <        ;;
3125 <      (skip)
3126 <        ;;
3127 <    esac
4389 >  if test -z "$GREP"; then
4390 >  ac_path_GREP_found=false
4391 >  # Loop through the user's path and test for each of PROGNAME-LIST
4392 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4393 > for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4394 > do
4395 >  IFS=$as_save_IFS
4396 >  test -z "$as_dir" && as_dir=.
4397 >    for ac_prog in grep ggrep; do
4398 >    for ac_exec_ext in '' $ac_executable_extensions; do
4399 >      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4400 >      { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4401 > # Check for GNU ac_path_GREP and select it if it is found.
4402 >  # Check for GNU $ac_path_GREP
4403 > case `"$ac_path_GREP" --version 2>&1` in
4404 > *GNU*)
4405 >  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4406 > *)
4407 >  ac_count=0
4408 >  $as_echo_n 0123456789 >"conftest.in"
4409 >  while :
4410 >  do
4411 >    cat "conftest.in" "conftest.in" >"conftest.tmp"
4412 >    mv "conftest.tmp" "conftest.in"
4413 >    cp "conftest.in" "conftest.nl"
4414 >    $as_echo 'GREP' >> "conftest.nl"
4415 >    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4416 >    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4417 >    as_fn_arith $ac_count + 1 && ac_count=$as_val
4418 >    if test $ac_count -gt ${ac_path_GREP_max-0}; then
4419 >      # Best one so far, save it but keep looking for a better one
4420 >      ac_cv_path_GREP="$ac_path_GREP"
4421 >      ac_path_GREP_max=$ac_count
4422 >    fi
4423 >    # 10*(2^10) chars as input seems more than enough
4424 >    test $ac_count -gt 10 && break
4425    done
4426 <
3130 <    ;;
4426 >  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4427   esac
4428  
4429 +      $ac_path_GREP_found && break 3
4430 +    done
4431 +  done
4432 +  done
4433 + IFS=$as_save_IFS
4434 +  if test -z "$ac_cv_path_GREP"; then
4435 +    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4436 +  fi
4437 + else
4438 +  ac_cv_path_GREP=$GREP
4439   fi
3134 – { echo "$as_me:$LINENO: result: $acx_mpi_cflags" >&5
3135 – echo "${ECHO_T}$acx_mpi_cflags" >&6; }
4440  
3137 –
3138 – { echo "$as_me:$LINENO: checking how to link MPI-C code" >&5
3139 – echo $ECHO_N "checking how to link MPI-C code... $ECHO_C" >&6; }
3140 – if test "${acx_mpi_libs+set}" = set; then
3141 –  echo $ECHO_N "(cached) $ECHO_C" >&6
3142 – else
3143 –
3144 – case $acx_cv_mpi_implementation in
3145 –  (lammpi)
3146 –    lfo="--showme:compile --showme:link"
3147 –    ;;
3148 –  (openmpi)
3149 –    lfo="--showme:link"
3150 –    ;;
3151 –  (mpich)
3152 –    case "$acx_mpi_compiler_path" in
3153 –      (*mpiCC)
3154 –        sc_cv_cn="-CC="
3155 –        ;;
3156 –      (*mpicxx)
3157 –        sc_cv_cn="-cxx="
3158 –        ;;
3159 –      (*mpicc)
3160 –        sc_cv_cn="-cc="
3161 –        ;;
3162 –      (*)
3163 –        sc_cv_cn=""
3164 –        ;;
3165 –    esac
3166 –    lfo="-link_info $sc_cv_cn"
3167 –    ;;
3168 – esac
3169 – echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_compiler_path $lfo || echo ' no'\`\"" >&5
3170 – mpi_pre_libs="`$acx_mpi_compiler_path $lfo 2>conftest.er1 || echo ' no'`"
3171 – grep -v '^ *+' conftest.er1 >conftest.err
3172 – rm -f conftest.er1
3173 – cat conftest.err >&5
3174 – echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
3175 – case "$mpi_pre_libs" in
3176 –  (*no)
3177 –    acx_mpi_libs=no
3178 –    ;;
3179 –  (*)
3180 –    acx_mpi_libs="$mpi_pre_libs"
3181 –    ;;
3182 – esac
3183 –
4441   fi
4442 < { echo "$as_me:$LINENO: result: $acx_mpi_libs" >&5
4443 < echo "${ECHO_T}$acx_mpi_libs" >&6; }
4442 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
4443 > $as_echo "$ac_cv_path_GREP" >&6; }
4444 > GREP="$ac_cv_path_GREP"
4445  
3188 – if test $acx_mpi_mpif90_path != no; then
4446  
4447 <
4448 <  { echo "$as_me:$LINENO: checking how to link MPI-Fortran code" >&5
4449 < echo $ECHO_N "checking how to link MPI-Fortran code... $ECHO_C" >&6; }
4450 < if test "${acx_mpi90_libs+set}" = set; then
3194 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4447 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
4448 > $as_echo_n "checking for egrep... " >&6; }
4449 > if ${ac_cv_path_EGREP+:} false; then :
4450 >  $as_echo_n "(cached) " >&6
4451   else
4452 +  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
4453 +   then ac_cv_path_EGREP="$GREP -E"
4454 +   else
4455 +     if test -z "$EGREP"; then
4456 +  ac_path_EGREP_found=false
4457 +  # Loop through the user's path and test for each of PROGNAME-LIST
4458 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4459 + for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4460 + do
4461 +  IFS=$as_save_IFS
4462 +  test -z "$as_dir" && as_dir=.
4463 +    for ac_prog in egrep; do
4464 +    for ac_exec_ext in '' $ac_executable_extensions; do
4465 +      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4466 +      { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4467 + # Check for GNU ac_path_EGREP and select it if it is found.
4468 +  # Check for GNU $ac_path_EGREP
4469 + case `"$ac_path_EGREP" --version 2>&1` in
4470 + *GNU*)
4471 +  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
4472 + *)
4473 +  ac_count=0
4474 +  $as_echo_n 0123456789 >"conftest.in"
4475 +  while :
4476 +  do
4477 +    cat "conftest.in" "conftest.in" >"conftest.tmp"
4478 +    mv "conftest.tmp" "conftest.in"
4479 +    cp "conftest.in" "conftest.nl"
4480 +    $as_echo 'EGREP' >> "conftest.nl"
4481 +    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4482 +    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4483 +    as_fn_arith $ac_count + 1 && ac_count=$as_val
4484 +    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
4485 +      # Best one so far, save it but keep looking for a better one
4486 +      ac_cv_path_EGREP="$ac_path_EGREP"
4487 +      ac_path_EGREP_max=$ac_count
4488 +    fi
4489 +    # 10*(2^10) chars as input seems more than enough
4490 +    test $ac_count -gt 10 && break
4491 +  done
4492 +  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4493 + esac
4494  
4495 <    echo "$as_me:$LINENO: mpi_pre_libs=\"\`$acx_mpi_mpif90_path $lfo || echo \" no\"\`\"" >&5
4496 <    mpi_pre_libs="`$acx_mpi_mpif90_path $lfo 2>conftest.er1 || echo " no"`"
4497 <    grep -v '^ *+' conftest.er1 >conftest.err
4498 <    rm -f conftest.er1
4499 <    cat conftest.err >&5
4500 <    echo "$as_me:$LINENO: mpi_pre_libs = $mpi_pre_libs" >&5
4501 <    case "$mpi_pre_libs" in
4502 <      (*no)
4503 <        acx_mpi90_libs=no
4504 <        ;;
3207 <      (*)
3208 <        acx_mpi90_libs="$mpi_pre_libs"
3209 <        ;;
3210 <    esac
3211 <
4495 >      $ac_path_EGREP_found && break 3
4496 >    done
4497 >  done
4498 >  done
4499 > IFS=$as_save_IFS
4500 >  if test -z "$ac_cv_path_EGREP"; then
4501 >    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
4502 >  fi
4503 > else
4504 >  ac_cv_path_EGREP=$EGREP
4505   fi
3213 – { echo "$as_me:$LINENO: result: $acx_mpi90_libs" >&5
3214 – echo "${ECHO_T}$acx_mpi90_libs" >&6; }
4506  
4507 <
4507 >   fi
4508   fi
4509 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
4510 + $as_echo "$ac_cv_path_EGREP" >&6; }
4511 + EGREP="$ac_cv_path_EGREP"
4512  
3219 – if test "$acx_mpi_cflags" = no -o "$acx_mpi_libs" = no; then
4513  
4514 < acx_mpi_cflags=""
4515 < acx_mpi_libs=""
4516 < USE_MPI="no"
4517 <        { echo "$as_me:$LINENO: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&5
4518 < echo "$as_me: WARNING: No suitable MPI implementation found. oopse_MPI will not be build." >&2;}
4514 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
4515 > $as_echo_n "checking whether ln -s works... " >&6; }
4516 > LN_S=$as_ln_s
4517 > if test "$LN_S" = "ln -s"; then
4518 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4519 > $as_echo "yes" >&6; }
4520   else
4521 <
4522 < MPI_CPPFLAGS=$acx_mpi_cflags
3229 <
3230 < MPI_LIBS=$acx_mpi_libs
3231 <
3232 < if test "$acx_mpi90_libs" != no; then
3233 <  MPI90_LIBS=$acx_mpi90_libs
3234 <
4521 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
4522 > $as_echo "no, using $LN_S" >&6; }
4523   fi
4524  
4525 < USE_MPI="yes"
4525 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4526 > $as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
4527 > set x ${MAKE-make}
4528 > ac_make=`$as_echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
4529 > if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
4530 >  $as_echo_n "(cached) " >&6
4531 > else
4532 >  cat >conftest.make <<\_ACEOF
4533 > SHELL = /bin/sh
4534 > all:
4535 >        @echo '@@@%%%=$(MAKE)=@@@%%%'
4536 > _ACEOF
4537 > # GNU make sometimes prints "make[1]: Entering ...", which would confuse us.
4538 > case `${MAKE-make} -f conftest.make 2>/dev/null` in
4539 >  *@@@%%%=?*=@@@%%%*)
4540 >    eval ac_cv_prog_make_${ac_make}_set=yes;;
4541 >  *)
4542 >    eval ac_cv_prog_make_${ac_make}_set=no;;
4543 > esac
4544 > rm -f conftest.make
4545   fi
4546 <
4547 <
4546 > if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
4547 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
4548 > $as_echo "yes" >&6; }
4549 >  SET_MAKE=
4550 > else
4551 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4552 > $as_echo "no" >&6; }
4553 >  SET_MAKE="MAKE=${MAKE-make}"
4554   fi
4555  
4556 <
4557 < fi
4558 <
4559 <
4560 <
4561 < # Checks for programs.
4562 < ac_ext=cpp
3250 < ac_cpp='$CXXCPP $CPPFLAGS'
3251 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3252 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3253 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3254 < if test -z "$CXX"; then
3255 <  if test -n "$CCC"; then
3256 <    CXX=$CCC
3257 <  else
3258 <    if test -n "$ac_tool_prefix"; then
3259 <  for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
3260 <  do
3261 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3262 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3263 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3264 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3265 < if test "${ac_cv_prog_CXX+set}" = set; then
3266 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4556 > if test -n "$ac_tool_prefix"; then
4557 >  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
4558 > set dummy ${ac_tool_prefix}ranlib; ac_word=$2
4559 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4560 > $as_echo_n "checking for $ac_word... " >&6; }
4561 > if ${ac_cv_prog_RANLIB+:} false; then :
4562 >  $as_echo_n "(cached) " >&6
4563   else
4564 <  if test -n "$CXX"; then
4565 <  ac_cv_prog_CXX="$CXX" # Let the user override the test.
4564 >  if test -n "$RANLIB"; then
4565 >  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4566   else
4567   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4568   for as_dir in $PATH
4569   do
4570    IFS=$as_save_IFS
4571    test -z "$as_dir" && as_dir=.
4572 <  for ac_exec_ext in '' $ac_executable_extensions; do
4572 >    for ac_exec_ext in '' $ac_executable_extensions; do
4573    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4574 <    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
4575 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4574 >    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
4575 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4576      break 2
4577    fi
4578   done
4579 < done
4579 >  done
4580   IFS=$as_save_IFS
4581  
4582   fi
4583   fi
4584 < CXX=$ac_cv_prog_CXX
4585 < if test -n "$CXX"; then
4586 <  { echo "$as_me:$LINENO: result: $CXX" >&5
4587 < echo "${ECHO_T}$CXX" >&6; }
4584 > RANLIB=$ac_cv_prog_RANLIB
4585 > if test -n "$RANLIB"; then
4586 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
4587 > $as_echo "$RANLIB" >&6; }
4588   else
4589 <  { echo "$as_me:$LINENO: result: no" >&5
4590 < echo "${ECHO_T}no" >&6; }
4589 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4590 > $as_echo "no" >&6; }
4591   fi
4592  
4593  
3298 –    test -n "$CXX" && break
3299 –  done
4594   fi
4595 < if test -z "$CXX"; then
4596 <  ac_ct_CXX=$CXX
4597 <  for ac_prog in $CXX $ac_cv_prog_acx_mpi_mpicxx icpc pathCC pgCC c++ xlc++ xlC g++ CC
4598 < do
4599 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
4600 < set dummy $ac_prog; ac_word=$2
4601 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
4602 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3309 < if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3310 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4595 > if test -z "$ac_cv_prog_RANLIB"; then
4596 >  ac_ct_RANLIB=$RANLIB
4597 >  # Extract the first word of "ranlib", so it can be a program name with args.
4598 > set dummy ranlib; ac_word=$2
4599 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4600 > $as_echo_n "checking for $ac_word... " >&6; }
4601 > if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
4602 >  $as_echo_n "(cached) " >&6
4603   else
4604 <  if test -n "$ac_ct_CXX"; then
4605 <  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
4604 >  if test -n "$ac_ct_RANLIB"; then
4605 >  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
4606   else
4607   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4608   for as_dir in $PATH
4609   do
4610    IFS=$as_save_IFS
4611    test -z "$as_dir" && as_dir=.
4612 <  for ac_exec_ext in '' $ac_executable_extensions; do
4612 >    for ac_exec_ext in '' $ac_executable_extensions; do
4613    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4614 <    ac_cv_prog_ac_ct_CXX="$ac_prog"
4615 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4614 >    ac_cv_prog_ac_ct_RANLIB="ranlib"
4615 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4616      break 2
4617    fi
4618   done
4619 < done
4619 >  done
4620   IFS=$as_save_IFS
4621  
4622   fi
4623   fi
4624 < ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
4625 < if test -n "$ac_ct_CXX"; then
4626 <  { echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
4627 < echo "${ECHO_T}$ac_ct_CXX" >&6; }
4624 > ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
4625 > if test -n "$ac_ct_RANLIB"; then
4626 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
4627 > $as_echo "$ac_ct_RANLIB" >&6; }
4628   else
4629 <  { echo "$as_me:$LINENO: result: no" >&5
4630 < echo "${ECHO_T}no" >&6; }
4629 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4630 > $as_echo "no" >&6; }
4631   fi
4632  
4633 <
4634 <  test -n "$ac_ct_CXX" && break
3343 < done
3344 <
3345 <  if test "x$ac_ct_CXX" = x; then
3346 <    CXX="g++"
4633 >  if test "x$ac_ct_RANLIB" = x; then
4634 >    RANLIB=":"
4635    else
4636      case $cross_compiling:$ac_tool_warned in
4637   yes:)
4638 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
4639 < whose name does not start with the host triplet.  If you think this
3352 < configuration is useful to you, please write to autoconf@gnu.org." >&5
3353 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
3354 < whose name does not start with the host triplet.  If you think this
3355 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
4638 > { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
4639 > $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
4640   ac_tool_warned=yes ;;
4641   esac
4642 <    CXX=$ac_ct_CXX
4642 >    RANLIB=$ac_ct_RANLIB
4643    fi
4644 + else
4645 +  RANLIB="$ac_cv_prog_RANLIB"
4646   fi
4647  
4648 +
4649 +   # Extract the first word of "perl", so it can be a program name with args.
4650 + set dummy perl; ac_word=$2
4651 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4652 + $as_echo_n "checking for $ac_word... " >&6; }
4653 + if ${ac_cv_path_PERLINTERP+:} false; then :
4654 +  $as_echo_n "(cached) " >&6
4655 + else
4656 +  case $PERLINTERP in
4657 +  [\\/]* | ?:[\\/]*)
4658 +  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
4659 +  ;;
4660 +  *)
4661 +  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4662 + for as_dir in $PATH
4663 + do
4664 +  IFS=$as_save_IFS
4665 +  test -z "$as_dir" && as_dir=.
4666 +    for ac_exec_ext in '' $ac_executable_extensions; do
4667 +  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4668 +    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
4669 +    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4670 +    break 2
4671    fi
4672 + done
4673 +  done
4674 + IFS=$as_save_IFS
4675 +
4676 +  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
4677 +  ;;
4678 + esac
4679   fi
4680 < # Provide some information about the compiler.
4681 < echo "$as_me:$LINENO: checking for C++ compiler version" >&5
4682 < ac_compiler=`set X $ac_compile; echo $2`
4683 < { (ac_try="$ac_compiler --version >&5"
4684 < case "(($ac_try" in
4685 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4686 <  *) ac_try_echo=$ac_try;;
4687 < esac
3372 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3373 <  (eval "$ac_compiler --version >&5") 2>&5
3374 <  ac_status=$?
3375 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3376 <  (exit $ac_status); }
3377 < { (ac_try="$ac_compiler -v >&5"
3378 < case "(($ac_try" in
3379 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3380 <  *) ac_try_echo=$ac_try;;
3381 < esac
3382 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3383 <  (eval "$ac_compiler -v >&5") 2>&5
3384 <  ac_status=$?
3385 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3386 <  (exit $ac_status); }
3387 < { (ac_try="$ac_compiler -V >&5"
3388 < case "(($ac_try" in
3389 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3390 <  *) ac_try_echo=$ac_try;;
3391 < esac
3392 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3393 <  (eval "$ac_compiler -V >&5") 2>&5
3394 <  ac_status=$?
3395 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3396 <  (exit $ac_status); }
4680 > PERLINTERP=$ac_cv_path_PERLINTERP
4681 > if test -n "$PERLINTERP"; then
4682 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PERLINTERP" >&5
4683 > $as_echo "$PERLINTERP" >&6; }
4684 > else
4685 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4686 > $as_echo "no" >&6; }
4687 > fi
4688  
3398 – cat >conftest.$ac_ext <<_ACEOF
3399 – /* confdefs.h.  */
3400 – _ACEOF
3401 – cat confdefs.h >>conftest.$ac_ext
3402 – cat >>conftest.$ac_ext <<_ACEOF
3403 – /* end confdefs.h.  */
4689  
4690 < int
4691 < main ()
3407 < {
4690 >   ac_cv_path_perlinterp="$PERLINTERP"
4691 >   _sHpB='#!'
4692  
3409 –  ;
3410 –  return 0;
3411 – }
3412 – _ACEOF
3413 – ac_clean_files_save=$ac_clean_files
3414 – ac_clean_files="$ac_clean_files a.out a.exe b.out"
3415 – # Try to create an executable without -o first, disregard a.out.
3416 – # It will help us diagnose broken compilers, and finding out an intuition
3417 – # of exeext.
3418 – { echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
3419 – echo $ECHO_N "checking for C++ compiler default output file name... $ECHO_C" >&6; }
3420 – ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3421 – #
3422 – # List of possible output files, starting from the most likely.
3423 – # The algorithm is not robust to junk in `.', hence go to wildcards (a.*)
3424 – # only as a last resort.  b.out is created by i960 compilers.
3425 – ac_files='a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out'
3426 – #
3427 – # The IRIX 6 linker writes into existing files which may not be
3428 – # executable, retaining their permissions.  Remove them first so a
3429 – # subsequent execution test works.
3430 – ac_rmfiles=
3431 – for ac_file in $ac_files
3432 – do
3433 –  case $ac_file in
3434 –    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
3435 –    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
3436 –  esac
3437 – done
3438 – rm -f $ac_rmfiles
4693  
4694 < if { (ac_try="$ac_link_default"
4695 < case "(($ac_try" in
4696 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3443 <  *) ac_try_echo=$ac_try;;
3444 < esac
3445 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3446 <  (eval "$ac_link_default") 2>&5
3447 <  ac_status=$?
3448 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3449 <  (exit $ac_status); }; then
3450 <  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
3451 < # So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
3452 < # in a Makefile.  We should not override ac_cv_exeext if it was cached,
3453 < # so that the user can short-circuit this test for compilers unknown to
3454 < # Autoconf.
3455 < for ac_file in $ac_files ''
3456 < do
3457 <  test -f "$ac_file" || continue
3458 <  case $ac_file in
3459 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj )
3460 <        ;;
3461 <    [ab].out )
3462 <        # We found the default executable, but exeext='' is most
3463 <        # certainly right.
3464 <        break;;
3465 <    *.* )
3466 <        if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
3467 <        then :; else
3468 <           ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3469 <        fi
3470 <        # We set ac_cv_exeext here because the later test for it is not
3471 <        # safe: cross compilers may not add the suffix if given an `-o'
3472 <        # argument, so we may need to know it at that point already.
3473 <        # Even if this section looks crufty: it has the advantage of
3474 <        # actually working.
3475 <        break;;
3476 <    * )
3477 <        break;;
3478 <  esac
3479 < done
3480 < test "$ac_cv_exeext" = no && ac_cv_exeext=
3481 <
4694 > # Check whether --with-perl-shebang was given.
4695 > if test "${with_perl_shebang+set}" = set; then :
4696 >  withval=$with_perl_shebang; opt_perl_shebang="$withval"
4697   else
4698 <  ac_file=''
4698 >                opt_perl_shebang="not_set"
4699   fi
4700  
4701 < { echo "$as_me:$LINENO: result: $ac_file" >&5
4702 < echo "${ECHO_T}$ac_file" >&6; }
4703 < if test -z "$ac_file"; then
4704 <  echo "$as_me: failed program was:" >&5
4705 < sed 's/^/| /' conftest.$ac_ext >&5
4701 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether explicit instead of detected sharpbang is to be used" >&5
4702 > $as_echo_n "checking whether explicit instead of detected sharpbang is to be used... " >&6; }
4703 > if ${ax_cv_opt_perl_shebang+:} false; then :
4704 >  $as_echo_n "(cached) " >&6
4705 > else
4706 >   case "$opt_perl_shebang" in
4707 >                      not_set  ) ax_cv_opt_perl_shebang=''
4708 >                               ;;
4709 >                         *     )
4710 >        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
4711 >                    esac
4712  
3492 – { { echo "$as_me:$LINENO: error: C++ compiler cannot create executables
3493 – See \`config.log' for more details." >&5
3494 – echo "$as_me: error: C++ compiler cannot create executables
3495 – See \`config.log' for more details." >&2;}
3496 –   { (exit 77); exit 77; }; }
4713   fi
4714 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_opt_perl_shebang" >&5
4715 + $as_echo "$ax_cv_opt_perl_shebang" >&6; }
4716 +   if test "A$ax_cv_opt_perl_shebang" != "A"
4717 +     then
4718 +       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
4719 +       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4720 +              { $as_echo "$as_me:${as_lineno-$LINENO}: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
4721 + $as_echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
4722  
4723 < ac_exeext=$ac_cv_exeext
4723 > # Automatic detection of sharpbang formula starts here
4724 >     else
4725 >   _somian_shbangperl=`$PERLINTERP -V:startperl`
4726 >   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
4727 >   { $as_echo "$as_me:${as_lineno-$LINENO}: checking for kernel sharpbang invocation to start perl" >&5
4728 > $as_echo_n "checking for kernel sharpbang invocation to start perl... " >&6; }
4729 > if ${ac_cv_sys_kernshrpbang_perl+:} false; then :
4730 >  $as_echo_n "(cached) " >&6
4731 > else
4732 >  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
4733 >        if test "x$_somian_kspb_perl" == x
4734 >          then _somian_ksbp_warn_empty='durnit'
4735 >          else
4736 >          case "A$_somian_kspb_perl" in
4737 >                 A#!*perl* )
4738 >           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
4739 >                        ;;
4740 >                     A*    )  _somian_ksbp_warn_defau='trouble'
4741 >                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
4742 >          esac
4743 >        fi
4744  
4745 < # Check that the compiler produces executables we can run.  If not, either
4746 < # the compiler is broken, or we cross compile.
4747 < { echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
4748 < echo $ECHO_N "checking whether the C++ compiler works... $ECHO_C" >&6; }
4749 < # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
4750 < # If not cross compiling, check that we can run a simple program.
4751 < if test "$cross_compiling" != yes; then
4752 <  if { ac_try='./$ac_file'
4753 <  { (case "(($ac_try" in
3510 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3511 <  *) ac_try_echo=$ac_try;;
3512 < esac
3513 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3514 <  (eval "$ac_try") 2>&5
3515 <  ac_status=$?
3516 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3517 <  (exit $ac_status); }; }; then
3518 <    cross_compiling=no
3519 <  else
3520 <    if test "$cross_compiling" = maybe; then
3521 <        cross_compiling=yes
3522 <    else
3523 <        { { echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
3524 < If you meant to cross compile, use \`--host'.
3525 < See \`config.log' for more details." >&5
3526 < echo "$as_me: error: cannot run C++ compiled programs.
3527 < If you meant to cross compile, use \`--host'.
3528 < See \`config.log' for more details." >&2;}
3529 <   { (exit 1); exit 1; }; }
4745 > fi
4746 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sys_kernshrpbang_perl" >&5
4747 > $as_echo "$ac_cv_sys_kernshrpbang_perl" >&6; }
4748 > # The above prints Checking ... result message to user.
4749 >   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
4750 >
4751 >    if test A${_somian_ksbp_warn_empty+set} == Aset
4752 >      then   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
4753 > $as_echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
4754      fi
4755 + # Inform user after printing result value
4756 +    if test A${_somian_ksbp_warn_defau+set} == Aset
4757 +      then { $as_echo "$as_me:${as_lineno-$LINENO}: Maybe Not good -" >&5
4758 + $as_echo "$as_me: Maybe Not good -" >&6;}
4759 +           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
4760 + $as_echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
4761 +      else { $as_echo "$as_me:${as_lineno-$LINENO}: OK Good result - " >&5
4762 + $as_echo "$as_me: OK Good result - " >&6;}
4763 +           { $as_echo "$as_me:${as_lineno-$LINENO}: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
4764 + $as_echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
4765 +    fi
4766    fi
3532 – fi
3533 – { echo "$as_me:$LINENO: result: yes" >&5
3534 – echo "${ECHO_T}yes" >&6; }
4767  
4768 < rm -f a.out a.exe conftest$ac_cv_exeext b.out
4769 < ac_clean_files=$ac_clean_files_save
4770 < # Check that the compiler produces executables we can run.  If not, either
4771 < # the compiler is broken, or we cross compile.
4772 < { echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
4773 < echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6; }
4774 < { echo "$as_me:$LINENO: result: $cross_compiling" >&5
4775 < echo "${ECHO_T}$cross_compiling" >&6; }
4776 <
4777 < { echo "$as_me:$LINENO: checking for suffix of executables" >&5
4778 < echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6; }
4779 < if { (ac_try="$ac_link"
4780 < case "(($ac_try" in
4781 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4782 <  *) ac_try_echo=$ac_try;;
4783 < esac
4784 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4785 <  (eval "$ac_link") 2>&5
4786 <  ac_status=$?
3555 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556 <  (exit $ac_status); }; then
3557 <  # If both `conftest.exe' and `conftest' are `present' (well, observable)
3558 < # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3559 < # work properly (i.e., refer to `conftest.exe'), while it won't with
3560 < # `rm'.
3561 < for ac_file in conftest.exe conftest conftest.*; do
3562 <  test -f "$ac_file" || continue
3563 <  case $ac_file in
3564 <    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.o | *.obj ) ;;
3565 <    *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3566 <          break;;
3567 <    * ) break;;
3568 <  esac
3569 < done
4768 > # Find a good install program.  We prefer a C program (faster),
4769 > # so one script is as good as another.  But avoid the broken or
4770 > # incompatible versions:
4771 > # SysV /etc/install, /usr/sbin/install
4772 > # SunOS /usr/etc/install
4773 > # IRIX /sbin/install
4774 > # AIX /bin/install
4775 > # AmigaOS /C/install, which installs bootblocks on floppy discs
4776 > # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
4777 > # AFS /usr/afsws/bin/install, which mishandles nonexistent args
4778 > # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
4779 > # OS/2's system install, which has a completely different semantic
4780 > # ./install, which can be erroneously created by make from ./install.sh.
4781 > # Reject install programs that cannot install multiple files.
4782 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
4783 > $as_echo_n "checking for a BSD-compatible install... " >&6; }
4784 > if test -z "$INSTALL"; then
4785 > if ${ac_cv_path_install+:} false; then :
4786 >  $as_echo_n "(cached) " >&6
4787   else
4788 <  { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
4789 < See \`config.log' for more details." >&5
4790 < echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
4791 < See \`config.log' for more details." >&2;}
4792 <   { (exit 1); exit 1; }; }
4793 < fi
4788 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4789 > for as_dir in $PATH
4790 > do
4791 >  IFS=$as_save_IFS
4792 >  test -z "$as_dir" && as_dir=.
4793 >    # Account for people who put trailing slashes in PATH elements.
4794 > case $as_dir/ in #((
4795 >  ./ | .// | /[cC]/* | \
4796 >  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
4797 >  ?:[\\/]os2[\\/]install[\\/]* | ?:[\\/]OS2[\\/]INSTALL[\\/]* | \
4798 >  /usr/ucb/* ) ;;
4799 >  *)
4800 >    # OSF1 and SCO ODT 3.0 have their own names for install.
4801 >    # Don't use installbsd from OSF since it installs stuff as root
4802 >    # by default.
4803 >    for ac_prog in ginstall scoinst install; do
4804 >      for ac_exec_ext in '' $ac_executable_extensions; do
4805 >        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
4806 >          if test $ac_prog = install &&
4807 >            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4808 >            # AIX install.  It has an incompatible calling convention.
4809 >            :
4810 >          elif test $ac_prog = install &&
4811 >            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
4812 >            # program-specific install script used by HP pwplus--don't use.
4813 >            :
4814 >          else
4815 >            rm -rf conftest.one conftest.two conftest.dir
4816 >            echo one > conftest.one
4817 >            echo two > conftest.two
4818 >            mkdir conftest.dir
4819 >            if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
4820 >              test -s conftest.one && test -s conftest.two &&
4821 >              test -s conftest.dir/conftest.one &&
4822 >              test -s conftest.dir/conftest.two
4823 >            then
4824 >              ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
4825 >              break 3
4826 >            fi
4827 >          fi
4828 >        fi
4829 >      done
4830 >    done
4831 >    ;;
4832 > esac
4833  
4834 < rm -f conftest$ac_cv_exeext
4835 < { echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3580 < echo "${ECHO_T}$ac_cv_exeext" >&6; }
4834 >  done
4835 > IFS=$as_save_IFS
4836  
4837 < rm -f conftest.$ac_ext
3583 < EXEEXT=$ac_cv_exeext
3584 < ac_exeext=$EXEEXT
3585 < { echo "$as_me:$LINENO: checking for suffix of object files" >&5
3586 < echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6; }
3587 < if test "${ac_cv_objext+set}" = set; then
3588 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3589 < else
3590 <  cat >conftest.$ac_ext <<_ACEOF
3591 < /* confdefs.h.  */
3592 < _ACEOF
3593 < cat confdefs.h >>conftest.$ac_ext
3594 < cat >>conftest.$ac_ext <<_ACEOF
3595 < /* end confdefs.h.  */
4837 > rm -rf conftest.one conftest.two conftest.dir
4838  
3597 – int
3598 – main ()
3599 – {
3600 –
3601 –  ;
3602 –  return 0;
3603 – }
3604 – _ACEOF
3605 – rm -f conftest.o conftest.obj
3606 – if { (ac_try="$ac_compile"
3607 – case "(($ac_try" in
3608 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3609 –  *) ac_try_echo=$ac_try;;
3610 – esac
3611 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3612 –  (eval "$ac_compile") 2>&5
3613 –  ac_status=$?
3614 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3615 –  (exit $ac_status); }; then
3616 –  for ac_file in conftest.o conftest.obj conftest.*; do
3617 –  test -f "$ac_file" || continue;
3618 –  case $ac_file in
3619 –    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf ) ;;
3620 –    *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3621 –       break;;
3622 –  esac
3623 – done
3624 – else
3625 –  echo "$as_me: failed program was:" >&5
3626 – sed 's/^/| /' conftest.$ac_ext >&5
3627 –
3628 – { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3629 – See \`config.log' for more details." >&5
3630 – echo "$as_me: error: cannot compute suffix of object files: cannot compile
3631 – See \`config.log' for more details." >&2;}
3632 –   { (exit 1); exit 1; }; }
4839   fi
4840 <
4841 < rm -f conftest.$ac_cv_objext conftest.$ac_ext
4840 >  if test "${ac_cv_path_install+set}" = set; then
4841 >    INSTALL=$ac_cv_path_install
4842 >  else
4843 >    # As a last resort, use the slow shell script.  Don't cache a
4844 >    # value for INSTALL within a source directory, because that will
4845 >    # break other packages using the cache if that directory is
4846 >    # removed, or if the value is a relative name.
4847 >    INSTALL=$ac_install_sh
4848 >  fi
4849   fi
4850 < { echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
4851 < echo "${ECHO_T}$ac_cv_objext" >&6; }
3639 < OBJEXT=$ac_cv_objext
3640 < ac_objext=$OBJEXT
3641 < { echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3642 < echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6; }
3643 < if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3644 <  echo $ECHO_N "(cached) $ECHO_C" >&6
3645 < else
3646 <  cat >conftest.$ac_ext <<_ACEOF
3647 < /* confdefs.h.  */
3648 < _ACEOF
3649 < cat confdefs.h >>conftest.$ac_ext
3650 < cat >>conftest.$ac_ext <<_ACEOF
3651 < /* end confdefs.h.  */
4850 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
4851 > $as_echo "$INSTALL" >&6; }
4852  
4853 < int
4854 < main ()
4855 < {
3656 < #ifndef __GNUC__
3657 <       choke me
3658 < #endif
4853 > # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
4854 > # It thinks the first close brace ends the variable substitution.
4855 > test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
4856  
4857 <  ;
4858 <  return 0;
4859 < }
4860 < _ACEOF
4861 < rm -f conftest.$ac_objext
4862 < if { (ac_try="$ac_compile"
4863 < case "(($ac_try" in
3667 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3668 <  *) ac_try_echo=$ac_try;;
4857 > test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
4858 >
4859 > test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
4860 >
4861 > case "x$INSTALL" in
4862 >   x/*) ;;
4863 >   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
4864   esac
4865 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4866 <  (eval "$ac_compile") 2>conftest.er1
4867 <  ac_status=$?
4868 <  grep -v '^ *+' conftest.er1 >conftest.err
4869 <  rm -f conftest.er1
4870 <  cat conftest.err >&5
4871 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3677 <  (exit $ac_status); } && {
3678 <         test -z "$ac_cxx_werror_flag" ||
3679 <         test ! -s conftest.err
3680 <       } && test -s conftest.$ac_objext; then
3681 <  ac_compiler_gnu=yes
4865 > MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f -m 755"
4866 > # Extract the first word of "ar", so it can be a program name with args.
4867 > set dummy ar; ac_word=$2
4868 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4869 > $as_echo_n "checking for $ac_word... " >&6; }
4870 > if ${ac_cv_prog_AR+:} false; then :
4871 >  $as_echo_n "(cached) " >&6
4872   else
4873 <  echo "$as_me: failed program was:" >&5
4874 < sed 's/^/| /' conftest.$ac_ext >&5
4873 >  if test -n "$AR"; then
4874 >  ac_cv_prog_AR="$AR" # Let the user override the test.
4875 > else
4876 > as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4877 > for as_dir in $PATH
4878 > do
4879 >  IFS=$as_save_IFS
4880 >  test -z "$as_dir" && as_dir=.
4881 >    for ac_exec_ext in '' $ac_executable_extensions; do
4882 >  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4883 >    ac_cv_prog_AR="ar"
4884 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
4885 >    break 2
4886 >  fi
4887 > done
4888 >  done
4889 > IFS=$as_save_IFS
4890  
4891 <        ac_compiler_gnu=no
4891 >  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
4892   fi
3688 –
3689 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3690 – ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3691 –
4893   fi
4894 < { echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4895 < echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6; }
4896 < GXX=`test $ac_compiler_gnu = yes && echo yes`
4897 < ac_test_CXXFLAGS=${CXXFLAGS+set}
3697 < ac_save_CXXFLAGS=$CXXFLAGS
3698 < { echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3699 < echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6; }
3700 < if test "${ac_cv_prog_cxx_g+set}" = set; then
3701 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4894 > AR=$ac_cv_prog_AR
4895 > if test -n "$AR"; then
4896 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
4897 > $as_echo "$AR" >&6; }
4898   else
4899 <  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
4900 <   ac_cxx_werror_flag=yes
4901 <   ac_cv_prog_cxx_g=no
3706 <   CXXFLAGS="-g"
3707 <   cat >conftest.$ac_ext <<_ACEOF
3708 < /* confdefs.h.  */
3709 < _ACEOF
3710 < cat confdefs.h >>conftest.$ac_ext
3711 < cat >>conftest.$ac_ext <<_ACEOF
3712 < /* end confdefs.h.  */
4899 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
4900 > $as_echo "no" >&6; }
4901 > fi
4902  
3714 – int
3715 – main ()
3716 – {
4903  
4904 <  ;
4905 <  return 0;
4906 < }
4907 < _ACEOF
4908 < rm -f conftest.$ac_objext
4909 < if { (ac_try="$ac_compile"
4910 < case "(($ac_try" in
4911 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4912 <  *) ac_try_echo=$ac_try;;
4913 < esac
4914 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4915 <  (eval "$ac_compile") 2>conftest.er1
4916 <  ac_status=$?
4917 <  grep -v '^ *+' conftest.er1 >conftest.err
3732 <  rm -f conftest.er1
3733 <  cat conftest.err >&5
3734 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3735 <  (exit $ac_status); } && {
3736 <         test -z "$ac_cxx_werror_flag" ||
3737 <         test ! -s conftest.err
3738 <       } && test -s conftest.$ac_objext; then
3739 <  ac_cv_prog_cxx_g=yes
3740 < else
3741 <  echo "$as_me: failed program was:" >&5
3742 < sed 's/^/| /' conftest.$ac_ext >&5
4904 > if test "$AR" = "NONE"; then
4905 >  cat >confcache <<\_ACEOF
4906 > # This file is a shell script that caches the results of configure
4907 > # tests run on this system so they can be shared between configure
4908 > # scripts and configure runs, see configure's option --config-cache.
4909 > # It is not useful on other systems.  If it contains results you don't
4910 > # want to keep, you may remove or edit it.
4911 > #
4912 > # config.status only pays attention to the cache file if you give it
4913 > # the --recheck option to rerun configure.
4914 > #
4915 > # `ac_cv_env_foo' variables (set or unset) will be overridden when
4916 > # loading this file, other *unset* `ac_cv_foo' will be assigned the
4917 > # following values.
4918  
3744 –        CXXFLAGS=""
3745 –      cat >conftest.$ac_ext <<_ACEOF
3746 – /* confdefs.h.  */
4919   _ACEOF
3748 – cat confdefs.h >>conftest.$ac_ext
3749 – cat >>conftest.$ac_ext <<_ACEOF
3750 – /* end confdefs.h.  */
4920  
4921 < int
4922 < main ()
4923 < {
4921 > # The following way of writing the cache mishandles newlines in values,
4922 > # but we know of no workaround that is simple, portable, and efficient.
4923 > # So, we kill variables containing newlines.
4924 > # Ultrix sh set writes to stderr and can't be redirected directly,
4925 > # and sets the high bit in the cache file unless we assign to the vars.
4926 > (
4927 >  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
4928 >    eval ac_val=\$$ac_var
4929 >    case $ac_val in #(
4930 >    *${as_nl}*)
4931 >      case $ac_var in #(
4932 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
4933 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
4934 >      esac
4935 >      case $ac_var in #(
4936 >      _ | IFS | as_nl) ;; #(
4937 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
4938 >      *) { eval $ac_var=; unset $ac_var;} ;;
4939 >      esac ;;
4940 >    esac
4941 >  done
4942  
4943 <  ;
4944 <  return 0;
4945 < }
4946 < _ACEOF
4947 < rm -f conftest.$ac_objext
4948 < if { (ac_try="$ac_compile"
4949 < case "(($ac_try" in
4950 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4951 <  *) ac_try_echo=$ac_try;;
4952 < esac
4953 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4954 <  (eval "$ac_compile") 2>conftest.er1
4955 <  ac_status=$?
4956 <  grep -v '^ *+' conftest.er1 >conftest.err
4957 <  rm -f conftest.er1
4958 <  cat conftest.err >&5
4959 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4960 <  (exit $ac_status); } && {
4961 <         test -z "$ac_cxx_werror_flag" ||
4962 <         test ! -s conftest.err
4963 <       } && test -s conftest.$ac_objext; then
4964 <  :
4965 < else
4966 <  echo "$as_me: failed program was:" >&5
4967 < sed 's/^/| /' conftest.$ac_ext >&5
4968 <
4969 <        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
4970 <         CXXFLAGS="-g"
4971 <         cat >conftest.$ac_ext <<_ACEOF
4972 < /* confdefs.h.  */
4973 < _ACEOF
4974 < cat confdefs.h >>conftest.$ac_ext
4975 < cat >>conftest.$ac_ext <<_ACEOF
4976 < /* end confdefs.h.  */
4977 <
4978 < int
4979 < main ()
4980 < {
4981 <
4982 <  ;
4983 <  return 0;
3797 < }
3798 < _ACEOF
3799 < rm -f conftest.$ac_objext
3800 < if { (ac_try="$ac_compile"
3801 < case "(($ac_try" in
3802 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3803 <  *) ac_try_echo=$ac_try;;
3804 < esac
3805 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3806 <  (eval "$ac_compile") 2>conftest.er1
3807 <  ac_status=$?
3808 <  grep -v '^ *+' conftest.er1 >conftest.err
3809 <  rm -f conftest.er1
3810 <  cat conftest.err >&5
3811 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3812 <  (exit $ac_status); } && {
3813 <         test -z "$ac_cxx_werror_flag" ||
3814 <         test ! -s conftest.err
3815 <       } && test -s conftest.$ac_objext; then
3816 <  ac_cv_prog_cxx_g=yes
3817 < else
3818 <  echo "$as_me: failed program was:" >&5
3819 < sed 's/^/| /' conftest.$ac_ext >&5
3820 <
3821 <
3822 < fi
3823 <
3824 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3825 < fi
3826 <
3827 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3828 < fi
3829 <
3830 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
3831 <   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
3832 < fi
3833 < { echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3834 < echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6; }
3835 < if test "$ac_test_CXXFLAGS" = set; then
3836 <  CXXFLAGS=$ac_save_CXXFLAGS
3837 < elif test $ac_cv_prog_cxx_g = yes; then
3838 <  if test "$GXX" = yes; then
3839 <    CXXFLAGS="-g -O2"
4943 >  (set) 2>&1 |
4944 >    case $as_nl`(ac_space=' '; set) 2>&1` in #(
4945 >    *${as_nl}ac_space=\ *)
4946 >      # `set' does not quote correctly, so add quotes: double-quote
4947 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
4948 >      sed -n \
4949 >        "s/'/'\\\\''/g;
4950 >          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4951 >      ;; #(
4952 >    *)
4953 >      # `set' quotes correctly as required by POSIX, so do not add quotes.
4954 >      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
4955 >      ;;
4956 >    esac |
4957 >    sort
4958 > ) |
4959 >  sed '
4960 >     /^ac_cv_env_/b end
4961 >     t clear
4962 >     :clear
4963 >     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4964 >     t end
4965 >     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4966 >     :end' >>confcache
4967 > if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
4968 >  if test -w "$cache_file"; then
4969 >    if test "x$cache_file" != "x/dev/null"; then
4970 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
4971 > $as_echo "$as_me: updating cache $cache_file" >&6;}
4972 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
4973 >        cat confcache >"$cache_file"
4974 >      else
4975 >        case $cache_file in #(
4976 >        */* | ?:*)
4977 >          mv -f confcache "$cache_file"$$ &&
4978 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
4979 >        *)
4980 >          mv -f confcache "$cache_file" ;;
4981 >        esac
4982 >      fi
4983 >    fi
4984    else
4985 <    CXXFLAGS="-g"
4985 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
4986 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
4987    fi
3843 – else
3844 –  if test "$GXX" = yes; then
3845 –    CXXFLAGS="-O2"
3846 –  else
3847 –    CXXFLAGS=
3848 –  fi
4988   fi
4989 < ac_ext=c
4990 < ac_cpp='$CPP $CPPFLAGS'
4991 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4992 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4993 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
4994 <
4995 < ac_ext=c
4996 < ac_cpp='$CPP $CPPFLAGS'
4997 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3859 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3860 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
3861 < if test -n "$ac_tool_prefix"; then
3862 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
3863 <  do
3864 <    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3865 < set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3866 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3867 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3868 < if test "${ac_cv_prog_CC+set}" = set; then
3869 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4989 > rm -f confcache
4990 >  exit 1
4991 > fi
4992 > # Extract the first word of "ps", so it can be a program name with args.
4993 > set dummy ps; ac_word=$2
4994 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
4995 > $as_echo_n "checking for $ac_word... " >&6; }
4996 > if ${ac_cv_path_PS+:} false; then :
4997 >  $as_echo_n "(cached) " >&6
4998   else
4999 <  if test -n "$CC"; then
5000 <  ac_cv_prog_CC="$CC" # Let the user override the test.
5001 < else
5002 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4999 >  case $PS in
5000 >  [\\/]* | ?:[\\/]*)
5001 >  ac_cv_path_PS="$PS" # Let the user override the test with a path.
5002 >  ;;
5003 >  *)
5004 >  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5005   for as_dir in $PATH
5006   do
5007    IFS=$as_save_IFS
5008    test -z "$as_dir" && as_dir=.
5009 <  for ac_exec_ext in '' $ac_executable_extensions; do
5009 >    for ac_exec_ext in '' $ac_executable_extensions; do
5010    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
5011 <    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
5012 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5011 >    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
5012 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
5013      break 2
5014    fi
5015   done
5016 < done
5016 >  done
5017   IFS=$as_save_IFS
5018  
5019 +  ;;
5020 + esac
5021   fi
5022 < fi
5023 < CC=$ac_cv_prog_CC
5024 < if test -n "$CC"; then
5025 <  { echo "$as_me:$LINENO: result: $CC" >&5
3894 < echo "${ECHO_T}$CC" >&6; }
5022 > PS=$ac_cv_path_PS
5023 > if test -n "$PS"; then
5024 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PS" >&5
5025 > $as_echo "$PS" >&6; }
5026   else
5027 <  { echo "$as_me:$LINENO: result: no" >&5
5028 < echo "${ECHO_T}no" >&6; }
5027 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
5028 > $as_echo "no" >&6; }
5029   fi
5030  
5031  
5032 <    test -n "$CC" && break
5033 <  done
5034 < fi
5035 < if test -z "$CC"; then
3905 <  ac_ct_CC=$CC
3906 <  for ac_prog in $CC $ac_cv_prog_acx_mpi_mpicc icc pathcc pgcc cc xlc gcc
3907 < do
3908 <  # Extract the first word of "$ac_prog", so it can be a program name with args.
3909 < set dummy $ac_prog; ac_word=$2
3910 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
3911 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
3912 < if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3913 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5032 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for POSIX or BSD ps syntax" >&5
5033 > $as_echo_n "checking for POSIX or BSD ps syntax... " >&6; }
5034 > if ${ac_cv_prog_ps_syntax+:} false; then :
5035 >  $as_echo_n "(cached) " >&6
5036   else
3915 –  if test -n "$ac_ct_CC"; then
3916 –  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3917 – else
3918 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3919 – for as_dir in $PATH
3920 – do
3921 –  IFS=$as_save_IFS
3922 –  test -z "$as_dir" && as_dir=.
3923 –  for ac_exec_ext in '' $ac_executable_extensions; do
3924 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3925 –    ac_cv_prog_ac_ct_CC="$ac_prog"
3926 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3927 –    break 2
3928 –  fi
3929 – done
3930 – done
3931 – IFS=$as_save_IFS
5037  
5038 +        if $PS ax -o rss > /dev/null 2>&1; then
5039 +                ac_cv_prog_ps_ax=yes
5040 +        else
5041 +                ac_cv_prog_ps_ax=no
5042 +        fi
5043 +        if $PS -ef -o rss > /dev/null 2>&1; then
5044 +                ac_cv_prog_ps_ef=yes
5045 +        else
5046 +                ac_cv_prog_ps_ef=no
5047 +        fi
5048 +        if test "$ac_cv_prog_ps_ax" = yes; then
5049 +                ac_cv_prog_ps_syntax=BSD
5050 +        else
5051 +                if test "$ac_cv_prog_ps_ef" = yes; then
5052 +                        ac_cv_prog_ps_syntax=POSIX
5053 +                else
5054 +                        as_fn_error $? "Could not determine ps syntax" "$LINENO" 5
5055 +                fi
5056 +        fi
5057 +
5058   fi
5059 < fi
5060 < ac_ct_CC=$ac_cv_prog_ac_ct_CC
3936 < if test -n "$ac_ct_CC"; then
3937 <  { echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3938 < echo "${ECHO_T}$ac_ct_CC" >&6; }
3939 < else
3940 <  { echo "$as_me:$LINENO: result: no" >&5
3941 < echo "${ECHO_T}no" >&6; }
3942 < fi
5059 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_ps_syntax" >&5
5060 > $as_echo "$ac_cv_prog_ps_syntax" >&6; }
5061  
5062 + cat >>confdefs.h <<_ACEOF
5063 + #define PSCOMMAND $PS
5064 + _ACEOF
5065  
5066 <  test -n "$ac_ct_CC" && break
3946 < done
5066 > if test "$ac_cv_prog_ps_syntax" = BSD; then
5067  
5068 <  if test "x$ac_ct_CC" = x; then
3949 <    CC=""
3950 <  else
3951 <    case $cross_compiling:$ac_tool_warned in
3952 < yes:)
3953 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
3954 < whose name does not start with the host triplet.  If you think this
3955 < configuration is useful to you, please write to autoconf@gnu.org." >&5
3956 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
3957 < whose name does not start with the host triplet.  If you think this
3958 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
3959 < ac_tool_warned=yes ;;
3960 < esac
3961 <    CC=$ac_ct_CC
3962 <  fi
3963 < fi
5068 > $as_echo "#define PSTYPE_IS_BSD 1" >>confdefs.h
5069  
5070 + else
5071 +   if test "$ac_cv_prog_ps_syntax" = POSIX; then
5072  
5073 < test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3967 < See \`config.log' for more details." >&5
3968 < echo "$as_me: error: no acceptable C compiler found in \$PATH
3969 < See \`config.log' for more details." >&2;}
3970 <   { (exit 1); exit 1; }; }
5073 > $as_echo "#define PSTYPE_IS_POSIX 1" >>confdefs.h
5074  
5075 < # Provide some information about the compiler.
5076 < echo "$as_me:$LINENO: checking for C compiler version" >&5
5077 < ac_compiler=`set X $ac_compile; echo $2`
5078 < { (ac_try="$ac_compiler --version >&5"
3976 < case "(($ac_try" in
3977 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3978 <  *) ac_try_echo=$ac_try;;
3979 < esac
3980 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3981 <  (eval "$ac_compiler --version >&5") 2>&5
3982 <  ac_status=$?
3983 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3984 <  (exit $ac_status); }
3985 < { (ac_try="$ac_compiler -v >&5"
3986 < case "(($ac_try" in
3987 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3988 <  *) ac_try_echo=$ac_try;;
3989 < esac
3990 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
3991 <  (eval "$ac_compiler -v >&5") 2>&5
3992 <  ac_status=$?
3993 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
3994 <  (exit $ac_status); }
3995 < { (ac_try="$ac_compiler -V >&5"
3996 < case "(($ac_try" in
3997 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3998 <  *) ac_try_echo=$ac_try;;
3999 < esac
4000 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4001 <  (eval "$ac_compiler -V >&5") 2>&5
4002 <  ac_status=$?
4003 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4004 <  (exit $ac_status); }
5075 >   else
5076 >       as_fn_error $? "Unknown ps syntax type!" "$LINENO" 5
5077 >   fi
5078 > fi
5079  
5080 < { echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
5081 < echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6; }
5082 < if test "${ac_cv_c_compiler_gnu+set}" = set; then
5083 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5080 > ac_ext=c
5081 > ac_cpp='$CPP $CPPFLAGS'
5082 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5083 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5084 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5085 >
5086 >
5087 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for asin in -lm" >&5
5088 > $as_echo_n "checking for asin in -lm... " >&6; }
5089 > if ${ac_cv_lib_m_asin+:} false; then :
5090 >  $as_echo_n "(cached) " >&6
5091   else
5092 <  cat >conftest.$ac_ext <<_ACEOF
5093 < /* confdefs.h.  */
5094 < _ACEOF
4014 < cat confdefs.h >>conftest.$ac_ext
4015 < cat >>conftest.$ac_ext <<_ACEOF
5092 >  ac_check_lib_save_LIBS=$LIBS
5093 > LIBS="-lm  $LIBS"
5094 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5095   /* end confdefs.h.  */
5096  
5097 + /* Override any GCC internal prototype to avoid an error.
5098 +   Use char because int might match the return type of a GCC
5099 +   builtin and then its argument prototype would still apply.  */
5100 + #ifdef __cplusplus
5101 + extern "C"
5102 + #endif
5103 + char asin ();
5104   int
5105   main ()
5106   {
5107 < #ifndef __GNUC__
4022 <       choke me
4023 < #endif
4024 <
5107 > return asin ();
5108    ;
5109    return 0;
5110   }
5111   _ACEOF
5112 < rm -f conftest.$ac_objext
5113 < if { (ac_try="$ac_compile"
4031 < case "(($ac_try" in
4032 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4033 <  *) ac_try_echo=$ac_try;;
4034 < esac
4035 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4036 <  (eval "$ac_compile") 2>conftest.er1
4037 <  ac_status=$?
4038 <  grep -v '^ *+' conftest.er1 >conftest.err
4039 <  rm -f conftest.er1
4040 <  cat conftest.err >&5
4041 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4042 <  (exit $ac_status); } && {
4043 <         test -z "$ac_c_werror_flag" ||
4044 <         test ! -s conftest.err
4045 <       } && test -s conftest.$ac_objext; then
4046 <  ac_compiler_gnu=yes
5112 > if ac_fn_c_try_link "$LINENO"; then :
5113 >  ac_cv_lib_m_asin=yes
5114   else
5115 <  echo "$as_me: failed program was:" >&5
4049 < sed 's/^/| /' conftest.$ac_ext >&5
4050 <
4051 <        ac_compiler_gnu=no
5115 >  ac_cv_lib_m_asin=no
5116   fi
5117 + rm -f core conftest.err conftest.$ac_objext \
5118 +    conftest$ac_exeext conftest.$ac_ext
5119 + LIBS=$ac_check_lib_save_LIBS
5120 + fi
5121 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_asin" >&5
5122 + $as_echo "$ac_cv_lib_m_asin" >&6; }
5123 + if test "x$ac_cv_lib_m_asin" = xyes; then :
5124 +  cat >>confdefs.h <<_ACEOF
5125 + #define HAVE_LIBM 1
5126 + _ACEOF
5127  
5128 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4055 < ac_cv_c_compiler_gnu=$ac_compiler_gnu
5128 >  LIBS="-lm $LIBS"
5129  
5130 + else
5131 +  exit
5132   fi
5133 < { echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
5134 < echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6; }
5135 < GCC=`test $ac_compiler_gnu = yes && echo yes`
5136 < ac_test_CFLAGS=${CFLAGS+set}
5137 < ac_save_CFLAGS=$CFLAGS
5138 < { echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
4064 < echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6; }
4065 < if test "${ac_cv_prog_cc_g+set}" = set; then
4066 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5133 >
5134 >
5135 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
5136 > $as_echo_n "checking for ANSI C header files... " >&6; }
5137 > if ${ac_cv_header_stdc+:} false; then :
5138 >  $as_echo_n "(cached) " >&6
5139   else
5140 <  ac_save_c_werror_flag=$ac_c_werror_flag
4069 <   ac_c_werror_flag=yes
4070 <   ac_cv_prog_cc_g=no
4071 <   CFLAGS="-g"
4072 <   cat >conftest.$ac_ext <<_ACEOF
4073 < /* confdefs.h.  */
4074 < _ACEOF
4075 < cat confdefs.h >>conftest.$ac_ext
4076 < cat >>conftest.$ac_ext <<_ACEOF
5140 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5141   /* end confdefs.h.  */
5142 + #include <stdlib.h>
5143 + #include <stdarg.h>
5144 + #include <string.h>
5145 + #include <float.h>
5146  
5147   int
5148   main ()
# Line 4084 | Line 5152 | _ACEOF
5152    return 0;
5153   }
5154   _ACEOF
5155 < rm -f conftest.$ac_objext
5156 < if { (ac_try="$ac_compile"
4089 < case "(($ac_try" in
4090 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4091 <  *) ac_try_echo=$ac_try;;
4092 < esac
4093 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4094 <  (eval "$ac_compile") 2>conftest.er1
4095 <  ac_status=$?
4096 <  grep -v '^ *+' conftest.er1 >conftest.err
4097 <  rm -f conftest.er1
4098 <  cat conftest.err >&5
4099 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4100 <  (exit $ac_status); } && {
4101 <         test -z "$ac_c_werror_flag" ||
4102 <         test ! -s conftest.err
4103 <       } && test -s conftest.$ac_objext; then
4104 <  ac_cv_prog_cc_g=yes
5155 > if ac_fn_c_try_compile "$LINENO"; then :
5156 >  ac_cv_header_stdc=yes
5157   else
5158 <  echo "$as_me: failed program was:" >&5
5159 < sed 's/^/| /' conftest.$ac_ext >&5
5158 >  ac_cv_header_stdc=no
5159 > fi
5160 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5161  
5162 <        CFLAGS=""
5163 <      cat >conftest.$ac_ext <<_ACEOF
5164 < /* confdefs.h.  */
4112 < _ACEOF
4113 < cat confdefs.h >>conftest.$ac_ext
4114 < cat >>conftest.$ac_ext <<_ACEOF
5162 > if test $ac_cv_header_stdc = yes; then
5163 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
5164 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5165   /* end confdefs.h.  */
5166 + #include <string.h>
5167  
4117 – int
4118 – main ()
4119 – {
4120 –
4121 –  ;
4122 –  return 0;
4123 – }
5168   _ACEOF
5169 < rm -f conftest.$ac_objext
5170 < if { (ac_try="$ac_compile"
5171 < case "(($ac_try" in
4128 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4129 <  *) ac_try_echo=$ac_try;;
4130 < esac
4131 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4132 <  (eval "$ac_compile") 2>conftest.er1
4133 <  ac_status=$?
4134 <  grep -v '^ *+' conftest.er1 >conftest.err
4135 <  rm -f conftest.er1
4136 <  cat conftest.err >&5
4137 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4138 <  (exit $ac_status); } && {
4139 <         test -z "$ac_c_werror_flag" ||
4140 <         test ! -s conftest.err
4141 <       } && test -s conftest.$ac_objext; then
4142 <  :
5169 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5170 >  $EGREP "memchr" >/dev/null 2>&1; then :
5171 >
5172   else
5173 <  echo "$as_me: failed program was:" >&5
5174 < sed 's/^/| /' conftest.$ac_ext >&5
5173 >  ac_cv_header_stdc=no
5174 > fi
5175 > rm -f conftest*
5176  
5177 <        ac_c_werror_flag=$ac_save_c_werror_flag
5178 <         CFLAGS="-g"
5179 <         cat >conftest.$ac_ext <<_ACEOF
5180 < /* confdefs.h.  */
5177 > fi
5178 >
5179 > if test $ac_cv_header_stdc = yes; then
5180 >  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
5181 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5182 > /* end confdefs.h.  */
5183 > #include <stdlib.h>
5184 >
5185   _ACEOF
5186 < cat confdefs.h >>conftest.$ac_ext
5187 < cat >>conftest.$ac_ext <<_ACEOF
5186 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
5187 >  $EGREP "free" >/dev/null 2>&1; then :
5188 >
5189 > else
5190 >  ac_cv_header_stdc=no
5191 > fi
5192 > rm -f conftest*
5193 >
5194 > fi
5195 >
5196 > if test $ac_cv_header_stdc = yes; then
5197 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
5198 >  if test "$cross_compiling" = yes; then :
5199 >  :
5200 > else
5201 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5202   /* end confdefs.h.  */
5203 + #include <ctype.h>
5204 + #include <stdlib.h>
5205 + #if ((' ' & 0x0FF) == 0x020)
5206 + # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
5207 + # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
5208 + #else
5209 + # define ISLOWER(c) \
5210 +                   (('a' <= (c) && (c) <= 'i') \
5211 +                     || ('j' <= (c) && (c) <= 'r') \
5212 +                     || ('s' <= (c) && (c) <= 'z'))
5213 + # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
5214 + #endif
5215  
5216 + #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
5217   int
5218   main ()
5219   {
5220 <
5221 <  ;
5220 >  int i;
5221 >  for (i = 0; i < 256; i++)
5222 >    if (XOR (islower (i), ISLOWER (i))
5223 >        || toupper (i) != TOUPPER (i))
5224 >      return 2;
5225    return 0;
5226   }
5227   _ACEOF
5228 < rm -f conftest.$ac_objext
5229 < if { (ac_try="$ac_compile"
4166 < case "(($ac_try" in
4167 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4168 <  *) ac_try_echo=$ac_try;;
4169 < esac
4170 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4171 <  (eval "$ac_compile") 2>conftest.er1
4172 <  ac_status=$?
4173 <  grep -v '^ *+' conftest.er1 >conftest.err
4174 <  rm -f conftest.er1
4175 <  cat conftest.err >&5
4176 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4177 <  (exit $ac_status); } && {
4178 <         test -z "$ac_c_werror_flag" ||
4179 <         test ! -s conftest.err
4180 <       } && test -s conftest.$ac_objext; then
4181 <  ac_cv_prog_cc_g=yes
5228 > if ac_fn_c_try_run "$LINENO"; then :
5229 >
5230   else
5231 <  echo "$as_me: failed program was:" >&5
5232 < sed 's/^/| /' conftest.$ac_ext >&5
5231 >  ac_cv_header_stdc=no
5232 > fi
5233 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
5234 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
5235 > fi
5236  
4186 –
5237   fi
5238 + fi
5239 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
5240 + $as_echo "$ac_cv_header_stdc" >&6; }
5241 + if test $ac_cv_header_stdc = yes; then
5242  
5243 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5243 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
5244 >
5245   fi
5246  
5247 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5247 > # On IRIX 5.3, sys/types and inttypes.h are conflicting.
5248 > for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
5249 >                  inttypes.h stdint.h unistd.h
5250 > do :
5251 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
5252 > ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
5253 > "
5254 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
5255 >  cat >>confdefs.h <<_ACEOF
5256 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
5257 > _ACEOF
5258 >
5259   fi
5260  
5261 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5262 <   ac_c_werror_flag=$ac_save_c_werror_flag
5261 > done
5262 >
5263 >
5264 > #
5265 > # Handle user hints
5266 > #
5267 >
5268 > # Check whether --with-zlib was given.
5269 > if test "${with_zlib+set}" = set; then :
5270 >  withval=$with_zlib; zlib_dir="$withval"
5271 > else
5272 >                zlib_dir="not_set"
5273   fi
5274 < { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
5275 < echo "${ECHO_T}$ac_cv_prog_cc_g" >&6; }
5276 < if test "$ac_test_CFLAGS" = set; then
5277 <  CFLAGS=$ac_save_CFLAGS
5278 < elif test $ac_cv_prog_cc_g = yes; then
5279 <  if test "$GCC" = yes; then
5280 <    CFLAGS="-g -O2"
5274 >
5275 > if test "$zlib_dir" != "no"; then
5276 >
5277 > if test "$zlib_dir" != "not_set" ; then
5278 >  if test -d "$zlib_dir"
5279 >  then
5280 >    ZLIB_HOME="$zlib_dir"
5281    else
5282 <    CFLAGS="-g"
5282 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
5283 > $as_echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
5284 >        ZLIB_HOME=/usr/local
5285 >        if test ! -f "${ZLIB_HOME}/include/zlib.h"
5286 >        then
5287 >                ZLIB_HOME=/usr
5288 >        fi
5289    fi
4208 – else
4209 –  if test "$GCC" = yes; then
4210 –    CFLAGS="-O2"
4211 –  else
4212 –    CFLAGS=
4213 –  fi
5290   fi
5291 < { echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
5292 < echo $ECHO_N "checking for $CC option to accept ISO C89... $ECHO_C" >&6; }
5293 < if test "${ac_cv_prog_cc_c89+set}" = set; then
5294 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5295 < else
5296 <  ac_cv_prog_cc_c89=no
5297 < ac_save_CC=$CC
5298 < cat >conftest.$ac_ext <<_ACEOF
5299 < /* confdefs.h.  */
4224 < _ACEOF
4225 < cat confdefs.h >>conftest.$ac_ext
4226 < cat >>conftest.$ac_ext <<_ACEOF
4227 < /* end confdefs.h.  */
4228 < #include <stdarg.h>
4229 < #include <stdio.h>
4230 < #include <sys/types.h>
4231 < #include <sys/stat.h>
4232 < /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
4233 < struct buf { int x; };
4234 < FILE * (*rcsopen) (struct buf *, struct stat *, int);
4235 < static char *e (p, i)
4236 <     char **p;
4237 <     int i;
4238 < {
4239 <  return p[i];
4240 < }
4241 < static char *f (char * (*g) (char **, int), char **p, ...)
4242 < {
4243 <  char *s;
4244 <  va_list v;
4245 <  va_start (v,p);
4246 <  s = g (p, va_arg (v,int));
4247 <  va_end (v);
4248 <  return s;
4249 < }
5291 > #
5292 > # Locate zlib, if wanted
5293 > #
5294 > if test -n "${ZLIB_HOME}"
5295 > then
5296 >        ZLIB_OLD_LDFLAGS=$LDFLAGS
5297 >        ZLIB_OLD_CFLAGS=$CFLAGS
5298 >        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
5299 >        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
5300  
5301 < /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
5302 <   function prototypes and stuff, but not '\xHH' hex character constants.
5303 <   These don't provoke an error unfortunately, instead are silently treated
5304 <   as 'x'.  The following induces an error, until -std is added to get
5305 <   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
4256 <   array size at least.  It's necessary to write '\x00'==0 to get something
4257 <   that's true only with -std.  */
4258 < int osf4_cc_array ['\x00' == 0 ? 1 : -1];
5301 >        ac_ext=c
5302 > ac_cpp='$CPP $CPPFLAGS'
5303 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5304 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5305 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5306  
5307 < /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
5308 <   inside strings and character constants.  */
5309 < #define FOO(x) 'x'
5310 < int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
5307 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inflateEnd in -lz" >&5
5308 > $as_echo_n "checking for inflateEnd in -lz... " >&6; }
5309 > if ${ac_cv_lib_z_inflateEnd+:} false; then :
5310 >  $as_echo_n "(cached) " >&6
5311 > else
5312 >  ac_check_lib_save_LIBS=$LIBS
5313 > LIBS="-lz  $LIBS"
5314 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5315 > /* end confdefs.h.  */
5316  
5317 < int test (int i, double x);
5318 < struct s1 {int (*f) (int a);};
5319 < struct s2 {int (*f) (double a);};
5320 < int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
5321 < int argc;
5322 < char **argv;
5317 > /* Override any GCC internal prototype to avoid an error.
5318 >   Use char because int might match the return type of a GCC
5319 >   builtin and then its argument prototype would still apply.  */
5320 > #ifdef __cplusplus
5321 > extern "C"
5322 > #endif
5323 > char inflateEnd ();
5324   int
5325   main ()
5326   {
5327 < return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
5327 > return inflateEnd ();
5328    ;
5329    return 0;
5330   }
5331   _ACEOF
5332 < for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
5333 <        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
4281 < do
4282 <  CC="$ac_save_CC $ac_arg"
4283 <  rm -f conftest.$ac_objext
4284 < if { (ac_try="$ac_compile"
4285 < case "(($ac_try" in
4286 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4287 <  *) ac_try_echo=$ac_try;;
4288 < esac
4289 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4290 <  (eval "$ac_compile") 2>conftest.er1
4291 <  ac_status=$?
4292 <  grep -v '^ *+' conftest.er1 >conftest.err
4293 <  rm -f conftest.er1
4294 <  cat conftest.err >&5
4295 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4296 <  (exit $ac_status); } && {
4297 <         test -z "$ac_c_werror_flag" ||
4298 <         test ! -s conftest.err
4299 <       } && test -s conftest.$ac_objext; then
4300 <  ac_cv_prog_cc_c89=$ac_arg
5332 > if ac_fn_c_try_link "$LINENO"; then :
5333 >  ac_cv_lib_z_inflateEnd=yes
5334   else
5335 <  echo "$as_me: failed program was:" >&5
4303 < sed 's/^/| /' conftest.$ac_ext >&5
4304 <
4305 <
5335 >  ac_cv_lib_z_inflateEnd=no
5336   fi
5337 + rm -f core conftest.err conftest.$ac_objext \
5338 +    conftest$ac_exeext conftest.$ac_ext
5339 + LIBS=$ac_check_lib_save_LIBS
5340 + fi
5341 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_inflateEnd" >&5
5342 + $as_echo "$ac_cv_lib_z_inflateEnd" >&6; }
5343 + if test "x$ac_cv_lib_z_inflateEnd" = xyes; then :
5344 +  zlib_cv_libz=yes
5345 + else
5346 +  zlib_cv_libz=no
5347 + fi
5348  
5349 < rm -f core conftest.err conftest.$ac_objext
5350 <  test "x$ac_cv_prog_cc_c89" != "xno" && break
5351 < done
5352 < rm -f conftest.$ac_ext
5353 < CC=$ac_save_CC
4313 <
5349 >        ac_fn_c_check_header_mongrel "$LINENO" "zlib.h" "ac_cv_header_zlib_h" "$ac_includes_default"
5350 > if test "x$ac_cv_header_zlib_h" = xyes; then :
5351 >  zlib_cv_zlib_h=yes
5352 > else
5353 >  zlib_cv_zlib_h=no
5354   fi
4315 – # AC_CACHE_VAL
4316 – case "x$ac_cv_prog_cc_c89" in
4317 –  x)
4318 –    { echo "$as_me:$LINENO: result: none needed" >&5
4319 – echo "${ECHO_T}none needed" >&6; } ;;
4320 –  xno)
4321 –    { echo "$as_me:$LINENO: result: unsupported" >&5
4322 – echo "${ECHO_T}unsupported" >&6; } ;;
4323 –  *)
4324 –    CC="$CC $ac_cv_prog_cc_c89"
4325 –    { echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
4326 – echo "${ECHO_T}$ac_cv_prog_cc_c89" >&6; } ;;
4327 – esac
5355  
5356  
5357 < ac_ext=c
5357 >        ac_ext=c
5358   ac_cpp='$CPP $CPPFLAGS'
5359   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5360   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5361   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5362  
4336 – ac_ext=${ac_fc_srcext-f}
4337 – ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
4338 – ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
4339 – ac_compiler_gnu=$ac_cv_fc_compiler_gnu
4340 – if test -n "$ac_tool_prefix"; then
4341 –  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
4342 –  do
4343 –    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4344 – set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4345 – { echo "$as_me:$LINENO: checking for $ac_word" >&5
4346 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4347 – if test "${ac_cv_prog_FC+set}" = set; then
4348 –  echo $ECHO_N "(cached) $ECHO_C" >&6
4349 – else
4350 –  if test -n "$FC"; then
4351 –  ac_cv_prog_FC="$FC" # Let the user override the test.
4352 – else
4353 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4354 – for as_dir in $PATH
4355 – do
4356 –  IFS=$as_save_IFS
4357 –  test -z "$as_dir" && as_dir=.
4358 –  for ac_exec_ext in '' $ac_executable_extensions; do
4359 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4360 –    ac_cv_prog_FC="$ac_tool_prefix$ac_prog"
4361 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4362 –    break 2
4363 –  fi
4364 – done
4365 – done
4366 – IFS=$as_save_IFS
5363  
5364 < fi
4369 < fi
4370 < FC=$ac_cv_prog_FC
4371 < if test -n "$FC"; then
4372 <  { echo "$as_me:$LINENO: result: $FC" >&5
4373 < echo "${ECHO_T}$FC" >&6; }
4374 < else
4375 <  { echo "$as_me:$LINENO: result: no" >&5
4376 < echo "${ECHO_T}no" >&6; }
4377 < fi
5364 >        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
5365  
5366 + $as_echo "#define HAVE_ZLIB_H 1" >>confdefs.h
5367  
4380 –    test -n "$FC" && break
4381 –  done
4382 – fi
4383 – if test -z "$FC"; then
4384 –  ac_ct_FC=$FC
4385 –  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
4386 – do
4387 –  # Extract the first word of "$ac_prog", so it can be a program name with args.
4388 – set dummy $ac_prog; ac_word=$2
4389 – { echo "$as_me:$LINENO: checking for $ac_word" >&5
4390 – echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
4391 – if test "${ac_cv_prog_ac_ct_FC+set}" = set; then
4392 –  echo $ECHO_N "(cached) $ECHO_C" >&6
4393 – else
4394 –  if test -n "$ac_ct_FC"; then
4395 –  ac_cv_prog_ac_ct_FC="$ac_ct_FC" # Let the user override the test.
4396 – else
4397 – as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4398 – for as_dir in $PATH
4399 – do
4400 –  IFS=$as_save_IFS
4401 –  test -z "$as_dir" && as_dir=.
4402 –  for ac_exec_ext in '' $ac_executable_extensions; do
4403 –  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
4404 –    ac_cv_prog_ac_ct_FC="$ac_prog"
4405 –    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4406 –    break 2
4407 –  fi
4408 – done
4409 – done
4410 – IFS=$as_save_IFS
5368  
5369 + $as_echo "#define HAVE_LIBZ 1" >>confdefs.h
5370 +
5371 +                ZLIB_INC_DIR="${ZLIB_HOME}/include"
5372 +                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
5373 +                ZLIB="-lz"
5374 +        else
5375 +                { $as_echo "$as_me:${as_lineno-$LINENO}: checking zlib in ${ZLIB_HOME}" >&5
5376 + $as_echo_n "checking zlib in ${ZLIB_HOME}... " >&6; }
5377 +                ZLIB_INC_DIR=
5378 +                ZLIB_LIB_DIR=
5379 +                ZLIB=
5380 +                LDFLAGS="$ZLIB_OLD_LDFLAGS"
5381 +                CFLAGS="$ZLIB_OLD_CFLAGS"
5382 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5383 + $as_echo "failed" >&6; }
5384 +                echo ""
5385 +                echo "*********************************************************"
5386 +                echo "* WARNING: Could not find a working zlib installation   *"
5387 +                echo "* If you need OpenMD to be able to deal with compressed *"
5388 +                echo "* trajectory dump files be sure to specify a valid zlib *"
5389 +                echo "* installation with --with-zlib=DIR                     *"
5390 +                echo "*                                                       *"
5391 +                echo "* OpenMD will still work without zlib installed.        *"
5392 +                echo "*********************************************************"
5393 +                echo ""
5394 +        fi
5395 +
5396 +
5397 +
5398   fi
5399   fi
5400 < ac_ct_FC=$ac_cv_prog_ac_ct_FC
5401 < if test -n "$ac_ct_FC"; then
5402 <  { echo "$as_me:$LINENO: result: $ac_ct_FC" >&5
5403 < echo "${ECHO_T}$ac_ct_FC" >&6; }
5400 >
5401 > #
5402 > # Handle user hints
5403 > #
5404 >
5405 > # Check whether --with-fftw was given.
5406 > if test "${with_fftw+set}" = set; then :
5407 >  withval=$with_fftw; fftw_dir="$withval"
5408   else
5409 <  { echo "$as_me:$LINENO: result: no" >&5
4420 < echo "${ECHO_T}no" >&6; }
5409 >             fftw_dir="not_set"
5410   fi
5411  
5412 + if test "$fftw_dir" != "no"; then
5413 +  if test "$fftw_dir" != "not_set" ; then
5414 +    if test -d "$fftw_dir"; then
5415 +      FFTW_HOME="$fftw_dir"
5416 +    else
5417 +      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
5418 + $as_echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
5419 +      FFTW_HOME=/usr/local
5420 +      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
5421 +        FFTW_HOME=/usr
5422 +      fi
5423 +    fi
5424 +    #
5425 +    # Locate fftw, if wanted
5426 +    #
5427 +    if test -n "${FFTW_HOME}"; then
5428 +      FFTW_OLD_LDFLAGS=$LDFLAGS
5429 +      FFTW_OLD_CFLAGS=$CFLAGS
5430 +      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
5431 +      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
5432  
5433 <  test -n "$ac_ct_FC" && break
5434 < done
5433 >      ac_ext=c
5434 > ac_cpp='$CPP $CPPFLAGS'
5435 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5436 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5437 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5438  
5439 <  if test "x$ac_ct_FC" = x; then
5440 <    FC=""
5441 <  else
5442 <    case $cross_compiling:$ac_tool_warned in
5443 < yes:)
5444 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
5445 < whose name does not start with the host triplet.  If you think this
5446 < configuration is useful to you, please write to autoconf@gnu.org." >&5
5447 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
5448 < whose name does not start with the host triplet.  If you think this
5449 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
5450 < ac_tool_warned=yes ;;
5451 < esac
5452 <    FC=$ac_ct_FC
5453 <  fi
5439 >      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftw_execute in -lfftw3" >&5
5440 > $as_echo_n "checking for fftw_execute in -lfftw3... " >&6; }
5441 > if ${ac_cv_lib_fftw3_fftw_execute+:} false; then :
5442 >  $as_echo_n "(cached) " >&6
5443 > else
5444 >  ac_check_lib_save_LIBS=$LIBS
5445 > LIBS="-lfftw3  $LIBS"
5446 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5447 > /* end confdefs.h.  */
5448 >
5449 > /* Override any GCC internal prototype to avoid an error.
5450 >   Use char because int might match the return type of a GCC
5451 >   builtin and then its argument prototype would still apply.  */
5452 > #ifdef __cplusplus
5453 > extern "C"
5454 > #endif
5455 > char fftw_execute ();
5456 > int
5457 > main ()
5458 > {
5459 > return fftw_execute ();
5460 >  ;
5461 >  return 0;
5462 > }
5463 > _ACEOF
5464 > if ac_fn_c_try_link "$LINENO"; then :
5465 >  ac_cv_lib_fftw3_fftw_execute=yes
5466 > else
5467 >  ac_cv_lib_fftw3_fftw_execute=no
5468   fi
5469 + rm -f core conftest.err conftest.$ac_objext \
5470 +    conftest$ac_exeext conftest.$ac_ext
5471 + LIBS=$ac_check_lib_save_LIBS
5472 + fi
5473 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw3_fftw_execute" >&5
5474 + $as_echo "$ac_cv_lib_fftw3_fftw_execute" >&6; }
5475 + if test "x$ac_cv_lib_fftw3_fftw_execute" = xyes; then :
5476 +  fftw_cv_libfftw3=yes
5477 + else
5478 +  fftw_cv_libfftw3=no
5479 + fi
5480  
5481 +      ac_fn_c_check_header_mongrel "$LINENO" "fftw3.h" "ac_cv_header_fftw3_h" "$ac_includes_default"
5482 + if test "x$ac_cv_header_fftw3_h" = xyes; then :
5483 +  fftw_cv_fftw3_h=yes
5484 + else
5485 +  fftw_cv_fftw3_h=no
5486 + fi
5487  
4445 – # Provide some information about the compiler.
4446 – echo "$as_me:$LINENO: checking for Fortran compiler version" >&5
4447 – ac_compiler=`set X $ac_compile; echo $2`
4448 – { (ac_try="$ac_compiler --version >&5"
4449 – case "(($ac_try" in
4450 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4451 –  *) ac_try_echo=$ac_try;;
4452 – esac
4453 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4454 –  (eval "$ac_compiler --version >&5") 2>&5
4455 –  ac_status=$?
4456 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4457 –  (exit $ac_status); }
4458 – { (ac_try="$ac_compiler -v >&5"
4459 – case "(($ac_try" in
4460 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4461 –  *) ac_try_echo=$ac_try;;
4462 – esac
4463 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4464 –  (eval "$ac_compiler -v >&5") 2>&5
4465 –  ac_status=$?
4466 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4467 –  (exit $ac_status); }
4468 – { (ac_try="$ac_compiler -V >&5"
4469 – case "(($ac_try" in
4470 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4471 –  *) ac_try_echo=$ac_try;;
4472 – esac
4473 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4474 –  (eval "$ac_compiler -V >&5") 2>&5
4475 –  ac_status=$?
4476 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4477 –  (exit $ac_status); }
4478 – rm -f a.out
5488  
5489 < # If we don't use `.F' as extension, the preprocessor is not run on the
5490 < # input file.  (Note that this only needs to work for GNU compilers.)
5491 < ac_save_ext=$ac_ext
5492 < ac_ext=F
5493 < { echo "$as_me:$LINENO: checking whether we are using the GNU Fortran compiler" >&5
4485 < echo $ECHO_N "checking whether we are using the GNU Fortran compiler... $ECHO_C" >&6; }
4486 < if test "${ac_cv_fc_compiler_gnu+set}" = set; then
4487 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5489 >      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
5490 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -lfftw" >&5
5491 > $as_echo_n "checking for fftwnd_one in -lfftw... " >&6; }
5492 > if ${ac_cv_lib_fftw_fftwnd_one+:} false; then :
5493 >  $as_echo_n "(cached) " >&6
5494   else
5495 <  cat >conftest.$ac_ext <<_ACEOF
5496 <      program main
5497 < #ifndef __GNUC__
5498 <       choke me
4493 < #endif
5495 >  ac_check_lib_save_LIBS=$LIBS
5496 > LIBS="-lfftw  $LIBS"
5497 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5498 > /* end confdefs.h.  */
5499  
5500 <      end
5500 > /* Override any GCC internal prototype to avoid an error.
5501 >   Use char because int might match the return type of a GCC
5502 >   builtin and then its argument prototype would still apply.  */
5503 > #ifdef __cplusplus
5504 > extern "C"
5505 > #endif
5506 > char fftwnd_one ();
5507 > int
5508 > main ()
5509 > {
5510 > return fftwnd_one ();
5511 >  ;
5512 >  return 0;
5513 > }
5514   _ACEOF
5515 < rm -f conftest.$ac_objext
5516 < if { (ac_try="$ac_compile"
4499 < case "(($ac_try" in
4500 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4501 <  *) ac_try_echo=$ac_try;;
4502 < esac
4503 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4504 <  (eval "$ac_compile") 2>conftest.er1
4505 <  ac_status=$?
4506 <  grep -v '^ *+' conftest.er1 >conftest.err
4507 <  rm -f conftest.er1
4508 <  cat conftest.err >&5
4509 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4510 <  (exit $ac_status); } && {
4511 <         test -z "$ac_fc_werror_flag" ||
4512 <         test ! -s conftest.err
4513 <       } && test -s conftest.$ac_objext; then
4514 <  ac_compiler_gnu=yes
5515 > if ac_fn_c_try_link "$LINENO"; then :
5516 >  ac_cv_lib_fftw_fftwnd_one=yes
5517   else
5518 <  echo "$as_me: failed program was:" >&5
5519 < sed 's/^/| /' conftest.$ac_ext >&5
5518 >  ac_cv_lib_fftw_fftwnd_one=no
5519 > fi
5520 > rm -f core conftest.err conftest.$ac_objext \
5521 >    conftest$ac_exeext conftest.$ac_ext
5522 > LIBS=$ac_check_lib_save_LIBS
5523 > fi
5524 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_fftw_fftwnd_one" >&5
5525 > $as_echo "$ac_cv_lib_fftw_fftwnd_one" >&6; }
5526 > if test "x$ac_cv_lib_fftw_fftwnd_one" = xyes; then :
5527 >  fftw_cv_libfftw=yes
5528 > else
5529 >  fftw_cv_libfftw=no
5530 > fi
5531  
5532 <        ac_compiler_gnu=no
5532 >        ac_fn_c_check_header_mongrel "$LINENO" "fftw.h" "ac_cv_header_fftw_h" "$ac_includes_default"
5533 > if test "x$ac_cv_header_fftw_h" = xyes; then :
5534 >  fftw_cv_fftw_h=yes
5535 > else
5536 >  fftw_cv_fftw_h=no
5537   fi
5538  
4522 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
4523 – ac_cv_fc_compiler_gnu=$ac_compiler_gnu
5539  
5540 < fi
5541 < { echo "$as_me:$LINENO: result: $ac_cv_fc_compiler_gnu" >&5
5542 < echo "${ECHO_T}$ac_cv_fc_compiler_gnu" >&6; }
5543 < ac_ext=$ac_save_ext
5544 < ac_test_FFLAGS=${FCFLAGS+set}
4530 < ac_save_FFLAGS=$FCFLAGS
4531 < FCFLAGS=
4532 < { echo "$as_me:$LINENO: checking whether $FC accepts -g" >&5
4533 < echo $ECHO_N "checking whether $FC accepts -g... $ECHO_C" >&6; }
4534 < if test "${ac_cv_prog_fc_g+set}" = set; then
4535 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5540 >        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
5541 >          { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fftwnd_one in -ldfftw" >&5
5542 > $as_echo_n "checking for fftwnd_one in -ldfftw... " >&6; }
5543 > if ${ac_cv_lib_dfftw_fftwnd_one+:} false; then :
5544 >  $as_echo_n "(cached) " >&6
5545   else
5546 <  FCFLAGS=-g
5547 < cat >conftest.$ac_ext <<_ACEOF
5548 <      program main
5546 >  ac_check_lib_save_LIBS=$LIBS
5547 > LIBS="-ldfftw  $LIBS"
5548 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5549 > /* end confdefs.h.  */
5550  
5551 <      end
5551 > /* Override any GCC internal prototype to avoid an error.
5552 >   Use char because int might match the return type of a GCC
5553 >   builtin and then its argument prototype would still apply.  */
5554 > #ifdef __cplusplus
5555 > extern "C"
5556 > #endif
5557 > char fftwnd_one ();
5558 > int
5559 > main ()
5560 > {
5561 > return fftwnd_one ();
5562 >  ;
5563 >  return 0;
5564 > }
5565   _ACEOF
5566 < rm -f conftest.$ac_objext
5567 < if { (ac_try="$ac_compile"
4545 < case "(($ac_try" in
4546 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4547 <  *) ac_try_echo=$ac_try;;
4548 < esac
4549 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4550 <  (eval "$ac_compile") 2>conftest.er1
4551 <  ac_status=$?
4552 <  grep -v '^ *+' conftest.er1 >conftest.err
4553 <  rm -f conftest.er1
4554 <  cat conftest.err >&5
4555 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4556 <  (exit $ac_status); } && {
4557 <         test -z "$ac_fc_werror_flag" ||
4558 <         test ! -s conftest.err
4559 <       } && test -s conftest.$ac_objext; then
4560 <  ac_cv_prog_fc_g=yes
5566 > if ac_fn_c_try_link "$LINENO"; then :
5567 >  ac_cv_lib_dfftw_fftwnd_one=yes
5568   else
5569 <  echo "$as_me: failed program was:" >&5
5570 < sed 's/^/| /' conftest.$ac_ext >&5
5569 >  ac_cv_lib_dfftw_fftwnd_one=no
5570 > fi
5571 > rm -f core conftest.err conftest.$ac_objext \
5572 >    conftest$ac_exeext conftest.$ac_ext
5573 > LIBS=$ac_check_lib_save_LIBS
5574 > fi
5575 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
5576 > $as_echo "$ac_cv_lib_dfftw_fftwnd_one" >&6; }
5577 > if test "x$ac_cv_lib_dfftw_fftwnd_one" = xyes; then :
5578 >  fftw_cv_libdfftw=yes
5579 > else
5580 >  fftw_cv_libdfftw=no
5581 > fi
5582  
5583 <        ac_cv_prog_fc_g=no
5583 >          ac_fn_c_check_header_mongrel "$LINENO" "dfftw.h" "ac_cv_header_dfftw_h" "$ac_includes_default"
5584 > if test "x$ac_cv_header_dfftw_h" = xyes; then :
5585 >  fftw_cv_dfftw_h=yes
5586 > else
5587 >  fftw_cv_dfftw_h=no
5588   fi
5589  
4568 – rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5590  
5591 < fi
5592 < { echo "$as_me:$LINENO: result: $ac_cv_prog_fc_g" >&5
5593 < echo "${ECHO_T}$ac_cv_prog_fc_g" >&6; }
5594 < if test "$ac_test_FFLAGS" = set; then
5595 <  FCFLAGS=$ac_save_FFLAGS
5596 < elif test $ac_cv_prog_fc_g = yes; then
5597 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
5598 <    FCFLAGS="-g -O2"
5599 <  else
5600 <    FCFLAGS="-g"
5591 >        fi
5592 >      fi
5593 >      ac_ext=c
5594 > ac_cpp='$CPP $CPPFLAGS'
5595 > ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5596 > ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5597 > ac_compiler_gnu=$ac_cv_c_compiler_gnu
5598 >
5599 >      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
5600 >
5601 > $as_echo "#define HAVE_FFTW3_H 1" >>confdefs.h
5602 >
5603 >        FFTW_INC_DIR="${FFTW_HOME}/include"
5604 >        FFTW_LIB_DIR="${FFTW_HOME}/lib"
5605 >        FFTW_LIBS="-lfftw3"
5606 >      else
5607 >        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
5608 >
5609 > $as_echo "#define HAVE_FFTW_H 1" >>confdefs.h
5610 >
5611 >          FFTW_INC_DIR="${FFTW_HOME}/include"
5612 >          FFTW_LIB_DIR="${FFTW_HOME}/lib"
5613 >          FFTW_LIBS="-lfftw"
5614 >        else
5615 >          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
5616 >
5617 > $as_echo "#define HAVE_DFFTW_H 1" >>confdefs.h
5618 >
5619 >            FFTW_INC_DIR="${FFTW_HOME}/include"
5620 >            FFTW_LIB_DIR="${FFTW_HOME}/lib"
5621 >            FFTW_LIBS="-ldfftw"
5622 >          else
5623 >            { $as_echo "$as_me:${as_lineno-$LINENO}: checking fftw in ${FFTW_HOME}" >&5
5624 > $as_echo_n "checking fftw in ${FFTW_HOME}... " >&6; }
5625 >            FFTW_INC_DIR=
5626 >            FFTW_LIB_DIR=
5627 >            FFTW_LIBS=
5628 >            LDFLAGS="$FFTW_OLD_LDFLAGS"
5629 >            CFLAGS="$FFTW_OLD_CFLAGS"
5630 >            { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
5631 > $as_echo "failed" >&6; }
5632 >            echo ""
5633 >            echo "*********************************************************"
5634 >            echo "* WARNING: Could not find a working FFTW installation   *"
5635 >            echo "* If you need the staticProps program to be able to     *"
5636 >            echo "* compute undulation spectra, be sure to specify a      *"
5637 >            echo "* valid fftw installation with --with-fftw=DIR          *"
5638 >            echo "*                                                       *"
5639 >            echo "* OpenMD will still work without fftw installed.        *"
5640 >            echo "*********************************************************"
5641 >            echo ""
5642 >          fi
5643 >        fi
5644 >      fi
5645 >
5646 >
5647 >
5648 >    fi
5649    fi
5650 + fi
5651 +
5652 + #
5653 + # Handle user hints
5654 + #
5655 +
5656 + # Check whether --with-qhull was given.
5657 + if test "${with_qhull+set}" = set; then :
5658 +  withval=$with_qhull; qhull_dir="$withval"
5659   else
5660 <  if test "x$ac_cv_fc_compiler_gnu" = xyes; then
4583 <    FCFLAGS="-O2"
4584 <  else
4585 <    FCFLAGS=
4586 <  fi
5660 >  qhull_dir="not_set"
5661   fi
5662  
5663 < ac_ext=c
5663 > QHULL_INC_DIR=
5664 > QHULL_LIB_DIR=
5665 > QHULL=
5666 > USE_QHULL=no
5667 >
5668 > if test "$qhull_dir" != "no"; then
5669 >   if test "$qhull_dir" != "not_set" ; then
5670 >     if test -d "$qhull_dir"; then
5671 >       QHULL_HOME="$qhull_dir"
5672 >     else
5673 >       { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
5674 > $as_echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
5675 >       QHULL_HOME=/usr/local
5676 >       if test ! -f "${QHULL_HOME}/include/qhull/libqhull.h"; then
5677 >          QHULL_HOME=/usr
5678 >       fi
5679 >     fi
5680 >   fi
5681 >   #
5682 >   # Locate qhull, if wanted
5683 >   #
5684 >   if test -n "${QHULL_HOME}"; then
5685 >        { $as_echo "$as_me:${as_lineno-$LINENO}: Checking for qhull in ${QHULL_HOME}" >&5
5686 > $as_echo "$as_me: Checking for qhull in ${QHULL_HOME}" >&6;}
5687 >
5688 >        ac_ext=c
5689   ac_cpp='$CPP $CPPFLAGS'
5690   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5691   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5692   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5693  
5694 < ac_ext=c
5694 >        QHULL_OLD_LDFLAGS=$LDFLAGS
5695 >        QHULL_OLD_CFLAGS=$CFLAGS
5696 >        QHULL_OLD_CPPFLAGS=$CPPFLAGS
5697 >        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
5698 >        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
5699 >        CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
5700 >        ac_fn_c_check_header_mongrel "$LINENO" "qhull/libqhull.h" "ac_cv_header_qhull_libqhull_h" "$ac_includes_default"
5701 > if test "x$ac_cv_header_qhull_libqhull_h" = xyes; then :
5702 >  qhull_cv_libqhull_h=yes
5703 > else
5704 >  qhull_cv_libqhull_h=no
5705 > fi
5706 >
5707 >
5708 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull" >&5
5709 > $as_echo_n "checking for qh_qhull in -lqhull... " >&6; }
5710 > if ${ac_cv_lib_qhull_qh_qhull+:} false; then :
5711 >  $as_echo_n "(cached) " >&6
5712 > else
5713 >  ac_check_lib_save_LIBS=$LIBS
5714 > LIBS="-lqhull  $LIBS"
5715 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5716 > /* end confdefs.h.  */
5717 >
5718 > /* Override any GCC internal prototype to avoid an error.
5719 >   Use char because int might match the return type of a GCC
5720 >   builtin and then its argument prototype would still apply.  */
5721 > #ifdef __cplusplus
5722 > extern "C"
5723 > #endif
5724 > char qh_qhull ();
5725 > int
5726 > main ()
5727 > {
5728 > return qh_qhull ();
5729 >  ;
5730 >  return 0;
5731 > }
5732 > _ACEOF
5733 > if ac_fn_c_try_link "$LINENO"; then :
5734 >  ac_cv_lib_qhull_qh_qhull=yes
5735 > else
5736 >  ac_cv_lib_qhull_qh_qhull=no
5737 > fi
5738 > rm -f core conftest.err conftest.$ac_objext \
5739 >    conftest$ac_exeext conftest.$ac_ext
5740 > LIBS=$ac_check_lib_save_LIBS
5741 > fi
5742 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull_qh_qhull" >&5
5743 > $as_echo "$ac_cv_lib_qhull_qh_qhull" >&6; }
5744 > if test "x$ac_cv_lib_qhull_qh_qhull" = xyes; then :
5745 >  qhull_cv_libqhull=yes
5746 > else
5747 >  qhull_cv_libqhull=no
5748 > fi
5749 >
5750 >        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for qh_qhull in -lqhull6" >&5
5751 > $as_echo_n "checking for qh_qhull in -lqhull6... " >&6; }
5752 > if ${ac_cv_lib_qhull6_qh_qhull+:} false; then :
5753 >  $as_echo_n "(cached) " >&6
5754 > else
5755 >  ac_check_lib_save_LIBS=$LIBS
5756 > LIBS="-lqhull6  $LIBS"
5757 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5758 > /* end confdefs.h.  */
5759 >
5760 > /* Override any GCC internal prototype to avoid an error.
5761 >   Use char because int might match the return type of a GCC
5762 >   builtin and then its argument prototype would still apply.  */
5763 > #ifdef __cplusplus
5764 > extern "C"
5765 > #endif
5766 > char qh_qhull ();
5767 > int
5768 > main ()
5769 > {
5770 > return qh_qhull ();
5771 >  ;
5772 >  return 0;
5773 > }
5774 > _ACEOF
5775 > if ac_fn_c_try_link "$LINENO"; then :
5776 >  ac_cv_lib_qhull6_qh_qhull=yes
5777 > else
5778 >  ac_cv_lib_qhull6_qh_qhull=no
5779 > fi
5780 > rm -f core conftest.err conftest.$ac_objext \
5781 >    conftest$ac_exeext conftest.$ac_ext
5782 > LIBS=$ac_check_lib_save_LIBS
5783 > fi
5784 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_qhull6_qh_qhull" >&5
5785 > $as_echo "$ac_cv_lib_qhull6_qh_qhull" >&6; }
5786 > if test "x$ac_cv_lib_qhull6_qh_qhull" = xyes; then :
5787 >  qhull_cv_libqhull6=yes
5788 > else
5789 >  qhull_cv_libqhull6=no
5790 > fi
5791 >
5792 >        LDFLAGS="$QHULL_OLD_LDFLAGS"
5793 >        CFLAGS="$QHULL_OLD_CFLAGS"
5794 >        CPPFLAGS="$QHULL_OLD_CPPFLAGS"
5795 >        ac_ext=c
5796   ac_cpp='$CPP $CPPFLAGS'
5797   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5798   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5799   ac_compiler_gnu=$ac_cv_c_compiler_gnu
5800 < { echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5801 < echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6; }
5802 < # On Suns, sometimes $CPP names a directory.
5803 < if test -n "$CPP" && test -d "$CPP"; then
5804 <  CPP=
5800 >
5801 >
5802 >        if test "$qhull_cv_libqhull_h" = "yes" -a "$qhull_cv_libqhull" = "yes" -o "$qhull_cv_libqhull6" = "yes"; then
5803 >
5804 > $as_echo "#define HAVE_LIBQHULL_H 1" >>confdefs.h
5805 >
5806 >           if test "$qhull_cv_libqhull" = "yes"; then
5807 >
5808 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5809 >
5810 >                QHULL="-lqhull"
5811 >           fi
5812 >           if test "$qhull_cv_libqhull6" = "yes"; then
5813 >
5814 > $as_echo "#define HAVE_QHULL 1" >>confdefs.h
5815 >
5816 >                QHULL="-lqhull6"
5817 >           fi
5818 >           USE_QHULL=yes
5819 >           QHULL_INC_DIR="${QHULL_HOME}/include"
5820 >           QHULL_LIB_DIR="${QHULL_HOME}/lib"
5821 >           { $as_echo "$as_me:${as_lineno-$LINENO}: result: Working qhull found, will proceed." >&5
5822 > $as_echo "Working qhull found, will proceed." >&6; }
5823 >        else
5824 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5825 > $as_echo "$as_me: WARNING: " >&2;}
5826 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Could not find a working qhull installation" >&5
5827 > $as_echo "$as_me: WARNING: Could not find a working qhull installation" >&2;}
5828 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: If you need OpenMD to be able to deal with convex    " >&5
5829 > $as_echo "$as_me: WARNING: If you need OpenMD to be able to deal with convex    " >&2;}
5830 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: hulls be sure to specify a valid qhull installation " >&5
5831 > $as_echo "$as_me: WARNING: hulls be sure to specify a valid qhull installation " >&2;}
5832 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: with --with-qhull=DIR                               " >&5
5833 > $as_echo "$as_me: WARNING: with --with-qhull=DIR                               " >&2;}
5834 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5835 > $as_echo "$as_me: WARNING: " >&2;}
5836 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: OpenMD will still work without qhull installed.      " >&5
5837 > $as_echo "$as_me: WARNING: OpenMD will still work without qhull installed.      " >&2;}
5838 >           { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: " >&5
5839 > $as_echo "$as_me: WARNING: " >&2;}
5840 >        fi
5841 >    fi
5842   fi
5843 < if test -z "$CPP"; then
5844 <  if test "${ac_cv_prog_CPP+set}" = set; then
5845 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5843 >
5844 >
5845 >
5846 >
5847 >
5848 > ac_ext=cpp
5849 > ac_cpp='$CXXCPP $CPPFLAGS'
5850 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5851 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5852 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5853 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
5854 > $as_echo_n "checking how to run the C++ preprocessor... " >&6; }
5855 > if test -z "$CXXCPP"; then
5856 >  if ${ac_cv_prog_CXXCPP+:} false; then :
5857 >  $as_echo_n "(cached) " >&6
5858   else
5859 <      # Double quotes because CPP needs to be expanded
5860 <    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5859 >      # Double quotes because CXXCPP needs to be expanded
5860 >    for CXXCPP in "$CXX -E" "/lib/cpp"
5861      do
5862        ac_preproc_ok=false
5863 < for ac_c_preproc_warn_flag in '' yes
5863 > for ac_cxx_preproc_warn_flag in '' yes
5864   do
5865    # Use a header file that comes with gcc, so configuring glibc
5866    # with a fresh cross-compiler works.
# Line 4619 | Line 5868 | do
5868    # <limits.h> exists even on freestanding compilers.
5869    # On the NeXT, cc -E runs the code through the compiler's parser,
5870    # not just through cpp. "Syntax error" is here to catch this case.
5871 <  cat >conftest.$ac_ext <<_ACEOF
4623 < /* confdefs.h.  */
4624 < _ACEOF
4625 < cat confdefs.h >>conftest.$ac_ext
4626 < cat >>conftest.$ac_ext <<_ACEOF
5871 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5872   /* end confdefs.h.  */
5873   #ifdef __STDC__
5874   # include <limits.h>
# Line 4632 | Line 5877 | _ACEOF
5877   #endif
5878                       Syntax error
5879   _ACEOF
5880 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4636 < case "(($ac_try" in
4637 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4638 <  *) ac_try_echo=$ac_try;;
4639 < esac
4640 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4641 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4642 <  ac_status=$?
4643 <  grep -v '^ *+' conftest.er1 >conftest.err
4644 <  rm -f conftest.er1
4645 <  cat conftest.err >&5
4646 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4647 <  (exit $ac_status); } >/dev/null && {
4648 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4649 <         test ! -s conftest.err
4650 <       }; then
4651 <  :
4652 < else
4653 <  echo "$as_me: failed program was:" >&5
4654 < sed 's/^/| /' conftest.$ac_ext >&5
5880 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5881  
5882 + else
5883    # Broken: fails on valid input.
5884   continue
5885   fi
5886 + rm -f conftest.err conftest.i conftest.$ac_ext
5887  
4660 – rm -f conftest.err conftest.$ac_ext
4661 –
5888    # OK, works on sane cases.  Now check whether nonexistent headers
5889    # can be detected and how.
5890 <  cat >conftest.$ac_ext <<_ACEOF
4665 < /* confdefs.h.  */
4666 < _ACEOF
4667 < cat confdefs.h >>conftest.$ac_ext
4668 < cat >>conftest.$ac_ext <<_ACEOF
5890 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5891   /* end confdefs.h.  */
5892   #include <ac_nonexistent.h>
5893   _ACEOF
5894 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4673 < case "(($ac_try" in
4674 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4675 <  *) ac_try_echo=$ac_try;;
4676 < esac
4677 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4678 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4679 <  ac_status=$?
4680 <  grep -v '^ *+' conftest.er1 >conftest.err
4681 <  rm -f conftest.er1
4682 <  cat conftest.err >&5
4683 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4684 <  (exit $ac_status); } >/dev/null && {
4685 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4686 <         test ! -s conftest.err
4687 <       }; then
5894 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5895    # Broken: success on invalid input.
5896   continue
5897   else
4691 –  echo "$as_me: failed program was:" >&5
4692 – sed 's/^/| /' conftest.$ac_ext >&5
4693 –
5898    # Passes both tests.
5899   ac_preproc_ok=:
5900   break
5901   fi
5902 + rm -f conftest.err conftest.i conftest.$ac_ext
5903  
4699 – rm -f conftest.err conftest.$ac_ext
4700 –
5904   done
5905   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5906 < rm -f conftest.err conftest.$ac_ext
5907 < if $ac_preproc_ok; then
5906 > rm -f conftest.i conftest.err conftest.$ac_ext
5907 > if $ac_preproc_ok; then :
5908    break
5909   fi
5910  
5911      done
5912 <    ac_cv_prog_CPP=$CPP
5912 >    ac_cv_prog_CXXCPP=$CXXCPP
5913  
5914   fi
5915 <  CPP=$ac_cv_prog_CPP
5915 >  CXXCPP=$ac_cv_prog_CXXCPP
5916   else
5917 <  ac_cv_prog_CPP=$CPP
5917 >  ac_cv_prog_CXXCPP=$CXXCPP
5918   fi
5919 < { echo "$as_me:$LINENO: result: $CPP" >&5
5920 < echo "${ECHO_T}$CPP" >&6; }
5919 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
5920 > $as_echo "$CXXCPP" >&6; }
5921   ac_preproc_ok=false
5922 < for ac_c_preproc_warn_flag in '' yes
5922 > for ac_cxx_preproc_warn_flag in '' yes
5923   do
5924    # Use a header file that comes with gcc, so configuring glibc
5925    # with a fresh cross-compiler works.
# Line 4724 | Line 5927 | do
5927    # <limits.h> exists even on freestanding compilers.
5928    # On the NeXT, cc -E runs the code through the compiler's parser,
5929    # not just through cpp. "Syntax error" is here to catch this case.
5930 <  cat >conftest.$ac_ext <<_ACEOF
4728 < /* confdefs.h.  */
4729 < _ACEOF
4730 < cat confdefs.h >>conftest.$ac_ext
4731 < cat >>conftest.$ac_ext <<_ACEOF
5930 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5931   /* end confdefs.h.  */
5932   #ifdef __STDC__
5933   # include <limits.h>
# Line 4737 | Line 5936 | _ACEOF
5936   #endif
5937                       Syntax error
5938   _ACEOF
5939 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4741 < case "(($ac_try" in
4742 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4743 <  *) ac_try_echo=$ac_try;;
4744 < esac
4745 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4746 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4747 <  ac_status=$?
4748 <  grep -v '^ *+' conftest.er1 >conftest.err
4749 <  rm -f conftest.er1
4750 <  cat conftest.err >&5
4751 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4752 <  (exit $ac_status); } >/dev/null && {
4753 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4754 <         test ! -s conftest.err
4755 <       }; then
4756 <  :
4757 < else
4758 <  echo "$as_me: failed program was:" >&5
4759 < sed 's/^/| /' conftest.$ac_ext >&5
5939 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5940  
5941 + else
5942    # Broken: fails on valid input.
5943   continue
5944   fi
5945 + rm -f conftest.err conftest.i conftest.$ac_ext
5946  
4765 – rm -f conftest.err conftest.$ac_ext
4766 –
5947    # OK, works on sane cases.  Now check whether nonexistent headers
5948    # can be detected and how.
5949 <  cat >conftest.$ac_ext <<_ACEOF
4770 < /* confdefs.h.  */
4771 < _ACEOF
4772 < cat confdefs.h >>conftest.$ac_ext
4773 < cat >>conftest.$ac_ext <<_ACEOF
5949 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
5950   /* end confdefs.h.  */
5951   #include <ac_nonexistent.h>
5952   _ACEOF
5953 < if { (ac_try="$ac_cpp conftest.$ac_ext"
4778 < case "(($ac_try" in
4779 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
4780 <  *) ac_try_echo=$ac_try;;
4781 < esac
4782 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
4783 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
4784 <  ac_status=$?
4785 <  grep -v '^ *+' conftest.er1 >conftest.err
4786 <  rm -f conftest.er1
4787 <  cat conftest.err >&5
4788 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4789 <  (exit $ac_status); } >/dev/null && {
4790 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
4791 <         test ! -s conftest.err
4792 <       }; then
5953 > if ac_fn_cxx_try_cpp "$LINENO"; then :
5954    # Broken: success on invalid input.
5955   continue
5956   else
4796 –  echo "$as_me: failed program was:" >&5
4797 – sed 's/^/| /' conftest.$ac_ext >&5
4798 –
5957    # Passes both tests.
5958   ac_preproc_ok=:
5959   break
5960   fi
5961 + rm -f conftest.err conftest.i conftest.$ac_ext
5962  
4804 – rm -f conftest.err conftest.$ac_ext
4805 –
5963   done
5964   # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5965 < rm -f conftest.err conftest.$ac_ext
5966 < if $ac_preproc_ok; then
5967 <  :
5965 > rm -f conftest.i conftest.err conftest.$ac_ext
5966 > if $ac_preproc_ok; then :
5967 >
5968   else
5969 <  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5970 < See \`config.log' for more details." >&5
5971 < echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5972 < See \`config.log' for more details." >&2;}
4816 <   { (exit 1); exit 1; }; }
5969 >  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
5970 > $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
5971 > as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
5972 > See \`config.log' for more details" "$LINENO" 5; }
5973   fi
5974  
5975 < ac_ext=c
5975 > ac_ext=cpp
5976 > ac_cpp='$CXXCPP $CPPFLAGS'
5977 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5978 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5979 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
5980 >
5981 >
5982 > #
5983 > # Handle user hints
5984 > #
5985 >
5986 > # Check whether --with-openbabel was given.
5987 > if test "${with_openbabel+set}" = set; then :
5988 >  withval=$with_openbabel; openbabel_dir="$withval"
5989 > else
5990 >                openbabel_dir="not_set"
5991 > fi
5992 >
5993 > if test "$openbabel_dir" != "no"; then
5994 >
5995 > if test "$openbabel_dir" != "not_set" ; then
5996 >  if test -d "$openbabel_dir"
5997 >  then
5998 >    OPENBABEL_HOME="$openbabel_dir"
5999 >  else
6000 >    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
6001 > $as_echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
6002 >        OPENBABEL_HOME=/usr/local
6003 >        if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
6004 >        then
6005 >                OPENBABEL_HOME=/usr
6006 >        fi
6007 >  fi
6008 > fi
6009 > #
6010 > # Locate openbabel, if wanted
6011 > #
6012 > if test -n "${OPENBABEL_HOME}"
6013 > then
6014 >
6015 >        ac_ext=cpp
6016 > ac_cpp='$CXXCPP $CPPFLAGS'
6017 > ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6018 > ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6019 > ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
6020 >
6021 >        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
6022 >        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
6023 >        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
6024 >        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
6025 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/babelconfig.h" "ac_cv_header_openbabel_babelconfig_h" "$ac_includes_default"
6026 > if test "x$ac_cv_header_openbabel_babelconfig_h" = xyes; then :
6027 >  openbabel_cv_openbabel_h=yes
6028 > else
6029 >  openbabel_cv_openbabel_h=no
6030 > fi
6031 >
6032 >
6033 >        ac_fn_cxx_check_header_mongrel "$LINENO" "openbabel/obconversion.h" "ac_cv_header_openbabel_obconversion_h" "$ac_includes_default"
6034 > if test "x$ac_cv_header_openbabel_obconversion_h" = xyes; then :
6035 >  openbabel_cv_obconversion_h=yes
6036 > else
6037 >  openbabel_cv_obconversion_h=no
6038 > fi
6039 >
6040 >
6041 >        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6042 > /* end confdefs.h.  */
6043 >
6044 >
6045 > #include <openbabel/babelconfig.h>
6046 > #include <openbabel/obconversion.h>
6047 > using namespace std;
6048 > using namespace OpenBabel;
6049 >
6050 > int
6051 > main ()
6052 > {
6053 >
6054 > OBConversion Conv(&cin, &cout);
6055 >
6056 >
6057 >  ;
6058 >  return 0;
6059 > }
6060 > _ACEOF
6061 > if ac_fn_cxx_try_link "$LINENO"; then :
6062 >
6063 >                openbabel_lib_found="yes"
6064 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: found" >&5
6065 > $as_echo "found" >&6; }
6066 >
6067 > else
6068 >
6069 >                openbabel_lib_found="no"
6070 >                { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
6071 > $as_echo "not found" >&6; }
6072 >
6073 >
6074 > fi
6075 > rm -f core conftest.err conftest.$ac_objext \
6076 >    conftest$ac_exeext conftest.$ac_ext
6077 >        ac_ext=c
6078   ac_cpp='$CPP $CPPFLAGS'
6079   ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6080   ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6081   ac_compiler_gnu=$ac_cv_c_compiler_gnu
6082  
6083 < { echo "$as_me:$LINENO: checking for grep that handles long lines and -e" >&5
6084 < echo $ECHO_N "checking for grep that handles long lines and -e... $ECHO_C" >&6; }
4827 < if test "${ac_cv_path_GREP+set}" = set; then
4828 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4829 < else
4830 <  # Extract the first word of "grep ggrep" to use in msg output
4831 < if test -z "$GREP"; then
4832 < set dummy grep ggrep; ac_prog_name=$2
4833 < if test "${ac_cv_path_GREP+set}" = set; then
4834 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4835 < else
4836 <  ac_path_GREP_found=false
4837 < # Loop through the user's path and test for each of PROGNAME-LIST
4838 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4839 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4840 < do
4841 <  IFS=$as_save_IFS
4842 <  test -z "$as_dir" && as_dir=.
4843 <  for ac_prog in grep ggrep; do
4844 <  for ac_exec_ext in '' $ac_executable_extensions; do
4845 <    ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
4846 <    { test -f "$ac_path_GREP" && $as_test_x "$ac_path_GREP"; } || continue
4847 <    # Check for GNU ac_path_GREP and select it if it is found.
4848 <  # Check for GNU $ac_path_GREP
4849 < case `"$ac_path_GREP" --version 2>&1` in
4850 < *GNU*)
4851 <  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
4852 < *)
4853 <  ac_count=0
4854 <  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
4855 <  while :
4856 <  do
4857 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
4858 <    mv "conftest.tmp" "conftest.in"
4859 <    cp "conftest.in" "conftest.nl"
4860 <    echo 'GREP' >> "conftest.nl"
4861 <    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4862 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4863 <    ac_count=`expr $ac_count + 1`
4864 <    if test $ac_count -gt ${ac_path_GREP_max-0}; then
4865 <      # Best one so far, save it but keep looking for a better one
4866 <      ac_cv_path_GREP="$ac_path_GREP"
4867 <      ac_path_GREP_max=$ac_count
4868 <    fi
4869 <    # 10*(2^10) chars as input seems more than enough
4870 <    test $ac_count -gt 10 && break
4871 <  done
4872 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4873 < esac
6083 >        LDFLAGS="$OPENBABEL_OLD_LDFLAGS"
6084 >        CPPFLAGS="$OPENBABEL_OLD_CPPFLAGS"
6085  
6086 +        if test "$openbabel_lib_found" = "yes" -a "$openbabel_cv_openbabel_h" = "yes" -a "$openbabel_cv_obconversion_h" = "yes"; then
6087 +                USE_OPENBABEL=yes
6088 +                OPENBABEL_INC_DIR="${OPENBABEL_HOME}/include/openbabel-2.0"
6089 +                OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
6090 +                OPENBABEL_LIB="-lopenbabel"
6091 +        else
6092 +                { $as_echo "$as_me:${as_lineno-$LINENO}: checking openbabel in ${OPENBABEL_HOME}" >&5
6093 + $as_echo_n "checking openbabel in ${OPENBABEL_HOME}... " >&6; }
6094 +                OPENBABEL_INC_DIR=
6095 +                OPENBABEL_LIB_DIR=
6096 +                OPENBABEL_LIB=
6097 +                USE_OPENBABEL=no
6098 +                { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
6099 + $as_echo "failed" >&6; }
6100 +                echo ""
6101 +                echo "*********************************************************"
6102 +                echo "* WARNING: Could not find a working openbabel-2.x       *"
6103 +                echo "* installation If you need OpenMD to be able to convert *"
6104 +                echo "* xyz or pdb files you need to specify a valid          *"
6105 +                echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
6106 +                echo "*                                                       *"
6107 +                echo "* OpenMD will still work without openbabel installed.   *"
6108 +                echo "*********************************************************"
6109 +                echo ""
6110 +        fi
6111  
4876 –    $ac_path_GREP_found && break 3
4877 –  done
4878 – done
6112  
4880 – done
4881 – IFS=$as_save_IFS
6113  
6114  
6115   fi
4885 –
4886 – GREP="$ac_cv_path_GREP"
4887 – if test -z "$GREP"; then
4888 –  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
4889 – echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
4890 –   { (exit 1); exit 1; }; }
6116   fi
6117  
4893 – else
4894 –  ac_cv_path_GREP=$GREP
4895 – fi
6118  
6119 <
6120 < fi
6121 < { echo "$as_me:$LINENO: result: $ac_cv_path_GREP" >&5
6122 < echo "${ECHO_T}$ac_cv_path_GREP" >&6; }
6123 < GREP="$ac_cv_path_GREP"
4902 <
4903 <
4904 < { echo "$as_me:$LINENO: checking for egrep" >&5
4905 < echo $ECHO_N "checking for egrep... $ECHO_C" >&6; }
4906 < if test "${ac_cv_path_EGREP+set}" = set; then
4907 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6119 > # Checks for header files.
6120 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
6121 > $as_echo_n "checking for ANSI C header files... " >&6; }
6122 > if ${ac_cv_header_stdc+:} false; then :
6123 >  $as_echo_n "(cached) " >&6
6124   else
6125 <  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
6126 <   then ac_cv_path_EGREP="$GREP -E"
6127 <   else
6128 <     # Extract the first word of "egrep" to use in msg output
6129 < if test -z "$EGREP"; then
6130 < set dummy egrep; ac_prog_name=$2
4915 < if test "${ac_cv_path_EGREP+set}" = set; then
4916 <  echo $ECHO_N "(cached) $ECHO_C" >&6
4917 < else
4918 <  ac_path_EGREP_found=false
4919 < # Loop through the user's path and test for each of PROGNAME-LIST
4920 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4921 < for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
4922 < do
4923 <  IFS=$as_save_IFS
4924 <  test -z "$as_dir" && as_dir=.
4925 <  for ac_prog in egrep; do
4926 <  for ac_exec_ext in '' $ac_executable_extensions; do
4927 <    ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
4928 <    { test -f "$ac_path_EGREP" && $as_test_x "$ac_path_EGREP"; } || continue
4929 <    # Check for GNU ac_path_EGREP and select it if it is found.
4930 <  # Check for GNU $ac_path_EGREP
4931 < case `"$ac_path_EGREP" --version 2>&1` in
4932 < *GNU*)
4933 <  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
4934 < *)
4935 <  ac_count=0
4936 <  echo $ECHO_N "0123456789$ECHO_C" >"conftest.in"
4937 <  while :
4938 <  do
4939 <    cat "conftest.in" "conftest.in" >"conftest.tmp"
4940 <    mv "conftest.tmp" "conftest.in"
4941 <    cp "conftest.in" "conftest.nl"
4942 <    echo 'EGREP' >> "conftest.nl"
4943 <    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
4944 <    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
4945 <    ac_count=`expr $ac_count + 1`
4946 <    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
4947 <      # Best one so far, save it but keep looking for a better one
4948 <      ac_cv_path_EGREP="$ac_path_EGREP"
4949 <      ac_path_EGREP_max=$ac_count
4950 <    fi
4951 <    # 10*(2^10) chars as input seems more than enough
4952 <    test $ac_count -gt 10 && break
4953 <  done
4954 <  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
4955 < esac
6125 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6126 > /* end confdefs.h.  */
6127 > #include <stdlib.h>
6128 > #include <stdarg.h>
6129 > #include <string.h>
6130 > #include <float.h>
6131  
6132 + int
6133 + main ()
6134 + {
6135  
6136 <    $ac_path_EGREP_found && break 3
6137 <  done
6138 < done
6139 <
6140 < done
6141 < IFS=$as_save_IFS
6142 <
6143 <
6136 >  ;
6137 >  return 0;
6138 > }
6139 > _ACEOF
6140 > if ac_fn_c_try_compile "$LINENO"; then :
6141 >  ac_cv_header_stdc=yes
6142 > else
6143 >  ac_cv_header_stdc=no
6144   fi
6145 + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6146  
6147 < EGREP="$ac_cv_path_EGREP"
6148 < if test -z "$EGREP"; then
6149 <  { { echo "$as_me:$LINENO: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&5
6150 < echo "$as_me: error: no acceptable $ac_prog_name could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" >&2;}
6151 <   { (exit 1); exit 1; }; }
4973 < fi
6147 > if test $ac_cv_header_stdc = yes; then
6148 >  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6149 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6150 > /* end confdefs.h.  */
6151 > #include <string.h>
6152  
6153 + _ACEOF
6154 + if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6155 +  $EGREP "memchr" >/dev/null 2>&1; then :
6156 +
6157   else
6158 <  ac_cv_path_EGREP=$EGREP
6158 >  ac_cv_header_stdc=no
6159   fi
6160 + rm -f conftest*
6161  
4979 –
4980 –   fi
6162   fi
4982 – { echo "$as_me:$LINENO: result: $ac_cv_path_EGREP" >&5
4983 – echo "${ECHO_T}$ac_cv_path_EGREP" >&6; }
4984 – EGREP="$ac_cv_path_EGREP"
6163  
6164 + if test $ac_cv_header_stdc = yes; then
6165 +  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6166 +  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6167 + /* end confdefs.h.  */
6168 + #include <stdlib.h>
6169  
6170 < { echo "$as_me:$LINENO: checking whether ln -s works" >&5
6171 < echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6; }
6172 < LN_S=$as_ln_s
4990 < if test "$LN_S" = "ln -s"; then
4991 <  { echo "$as_me:$LINENO: result: yes" >&5
4992 < echo "${ECHO_T}yes" >&6; }
4993 < else
4994 <  { echo "$as_me:$LINENO: result: no, using $LN_S" >&5
4995 < echo "${ECHO_T}no, using $LN_S" >&6; }
4996 < fi
6170 > _ACEOF
6171 > if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6172 >  $EGREP "free" >/dev/null 2>&1; then :
6173  
4998 – { echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
4999 – echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6; }
5000 – set x ${MAKE-make}; ac_make=`echo "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'`
5001 – if { as_var=ac_cv_prog_make_${ac_make}_set; eval "test \"\${$as_var+set}\" = set"; }; then
5002 –  echo $ECHO_N "(cached) $ECHO_C" >&6
6174   else
6175 <  cat >conftest.make <<\_ACEOF
5005 < SHELL = /bin/sh
5006 < all:
5007 <        @echo '@@@%%%=$(MAKE)=@@@%%%'
5008 < _ACEOF
5009 < # GNU make sometimes prints "make[1]: Entering...", which would confuse us.
5010 < case `${MAKE-make} -f conftest.make 2>/dev/null` in
5011 <  *@@@%%%=?*=@@@%%%*)
5012 <    eval ac_cv_prog_make_${ac_make}_set=yes;;
5013 <  *)
5014 <    eval ac_cv_prog_make_${ac_make}_set=no;;
5015 < esac
5016 < rm -f conftest.make
6175 >  ac_cv_header_stdc=no
6176   fi
6177 < if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
5019 <  { echo "$as_me:$LINENO: result: yes" >&5
5020 < echo "${ECHO_T}yes" >&6; }
5021 <  SET_MAKE=
5022 < else
5023 <  { echo "$as_me:$LINENO: result: no" >&5
5024 < echo "${ECHO_T}no" >&6; }
5025 <  SET_MAKE="MAKE=${MAKE-make}"
5026 < fi
6177 > rm -f conftest*
6178  
6179 < if test -n "$ac_tool_prefix"; then
6180 <  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
6181 < set dummy ${ac_tool_prefix}ranlib; ac_word=$2
6182 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
6183 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
6184 < if test "${ac_cv_prog_RANLIB+set}" = set; then
6185 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6186 < else
6187 <  if test -n "$RANLIB"; then
6188 <  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
6189 < else
6190 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6191 < for as_dir in $PATH
6192 < do
6193 <  IFS=$as_save_IFS
6194 <  test -z "$as_dir" && as_dir=.
6195 <  for ac_exec_ext in '' $ac_executable_extensions; do
6196 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6197 <    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
6198 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6199 <    break 2
6200 <  fi
6201 < done
6202 < done
6203 < IFS=$as_save_IFS
6204 <
6205 < fi
6206 < fi
6207 < RANLIB=$ac_cv_prog_RANLIB
6208 < if test -n "$RANLIB"; then
6209 <  { echo "$as_me:$LINENO: result: $RANLIB" >&5
6210 < echo "${ECHO_T}$RANLIB" >&6; }
6211 < else
6212 <  { echo "$as_me:$LINENO: result: no" >&5
6213 < echo "${ECHO_T}no" >&6; }
6214 < fi
6215 <
6216 <
6217 < fi
6218 < if test -z "$ac_cv_prog_RANLIB"; then
6219 <  ac_ct_RANLIB=$RANLIB
6220 <  # Extract the first word of "ranlib", so it can be a program name with args.
6221 < set dummy ranlib; ac_word=$2
6222 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
6223 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
6224 < if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
6225 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6226 < else
6227 <  if test -n "$ac_ct_RANLIB"; then
6228 <  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
6229 < else
6230 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6231 < for as_dir in $PATH
6232 < do
6233 <  IFS=$as_save_IFS
6234 <  test -z "$as_dir" && as_dir=.
6235 <  for ac_exec_ext in '' $ac_executable_extensions; do
6236 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6237 <    ac_cv_prog_ac_ct_RANLIB="ranlib"
6238 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6239 <    break 2
6240 <  fi
6241 < done
6242 < done
6243 < IFS=$as_save_IFS
6244 <
6245 < fi
6246 < fi
6247 < ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
6248 < if test -n "$ac_ct_RANLIB"; then
6249 <  { echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
6250 < echo "${ECHO_T}$ac_ct_RANLIB" >&6; }
6251 < else
6252 <  { echo "$as_me:$LINENO: result: no" >&5
6253 < echo "${ECHO_T}no" >&6; }
6254 < fi
6255 <
6256 <  if test "x$ac_ct_RANLIB" = x; then
6257 <    RANLIB=":"
6258 <  else
6259 <    case $cross_compiling:$ac_tool_warned in
6260 < yes:)
6261 < { echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
6262 < whose name does not start with the host triplet.  If you think this
6263 < configuration is useful to you, please write to autoconf@gnu.org." >&5
6264 < echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
6265 < whose name does not start with the host triplet.  If you think this
6266 < configuration is useful to you, please write to autoconf@gnu.org." >&2;}
6267 < ac_tool_warned=yes ;;
6268 < esac
6269 <    RANLIB=$ac_ct_RANLIB
6270 <  fi
6271 < else
6272 <  RANLIB="$ac_cv_prog_RANLIB"
6273 < fi
6274 <
6275 <
6276 <   # Extract the first word of "perl", so it can be a program name with args.
6277 < set dummy perl; ac_word=$2
6278 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
6279 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
6280 < if test "${ac_cv_path_PERLINTERP+set}" = set; then
6281 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6282 < else
6283 <  case $PERLINTERP in
6284 <  [\\/]* | ?:[\\/]*)
6285 <  ac_cv_path_PERLINTERP="$PERLINTERP" # Let the user override the test with a path.
6286 <  ;;
6287 <  *)
6288 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6289 < for as_dir in $PATH
6290 < do
6291 <  IFS=$as_save_IFS
6292 <  test -z "$as_dir" && as_dir=.
6293 <  for ac_exec_ext in '' $ac_executable_extensions; do
6294 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6295 <    ac_cv_path_PERLINTERP="$as_dir/$ac_word$ac_exec_ext"
6296 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6297 <    break 2
6298 <  fi
6299 < done
6300 < done
6301 < IFS=$as_save_IFS
6302 <
6303 <  test -z "$ac_cv_path_PERLINTERP" && ac_cv_path_PERLINTERP="perl"
6304 <  ;;
6305 < esac
6306 < fi
6307 < PERLINTERP=$ac_cv_path_PERLINTERP
6308 < if test -n "$PERLINTERP"; then
6309 <  { echo "$as_me:$LINENO: result: $PERLINTERP" >&5
6310 < echo "${ECHO_T}$PERLINTERP" >&6; }
6311 < else
6312 <  { echo "$as_me:$LINENO: result: no" >&5
6313 < echo "${ECHO_T}no" >&6; }
6314 < fi
6315 <
6316 <
6317 <   ac_cv_path_perlinterp="$PERLINTERP"
6318 <   _sHpB='#!'
6319 <
6320 <
6321 < # Check whether --with-perl-shebang was given.
6322 < if test "${with_perl_shebang+set}" = set; then
6323 <  withval=$with_perl_shebang; opt_perl_shebang="$withval"
6324 < else
6325 <                opt_perl_shebang="not_set"
6326 < fi
6327 <
6328 <   { echo "$as_me:$LINENO: checking whether explicit instead of detected sharpbang is to be used" >&5
6329 < echo $ECHO_N "checking whether explicit instead of detected sharpbang is to be used... $ECHO_C" >&6; }
6330 < if test "${ax_cv_opt_perl_shebang+set}" = set; then
6331 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6332 < else
6333 <   case "$opt_perl_shebang" in
6334 <                      not_set  ) ax_cv_opt_perl_shebang=''
6335 <                               ;;
6336 <                         *     )
6337 <        ax_cv_opt_perl_shebang=`echo "$opt_perl_shebang" | sed -e's|^#!\s*\(.*\)$|\1|'`
6338 <                    esac
6339 <
6340 < fi
6341 < { echo "$as_me:$LINENO: result: $ax_cv_opt_perl_shebang" >&5
6342 < echo "${ECHO_T}$ax_cv_opt_perl_shebang" >&6; }
6343 <   if test "A$ax_cv_opt_perl_shebang" != "A"
6344 <     then
6345 <       ac_cv_sys_kernshrpbang_perl="$ax_cv_opt_perl_shebang"
6346 <       PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
6347 <              { echo "$as_me:$LINENO: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&5
6348 < echo "$as_me: OK - PERL_SHEBANG is $_sHpB$PERL_SHEBANG." >&6;}
6349 <
6350 < # Automatic detection of sharpbang formula starts here
6351 <     else
6352 <   _somian_shbangperl=`$PERLINTERP -V:startperl`
6353 <   negclass="[^']"; # must leave this comment:  m4 will remove the outer brackets for us, heheh
6354 <   { echo "$as_me:$LINENO: checking for kernel sharpbang invocation to start perl" >&5
6355 < echo $ECHO_N "checking for kernel sharpbang invocation to start perl... $ECHO_C" >&6; }
6356 < if test "${ac_cv_sys_kernshrpbang_perl+set}" = set; then
6357 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6358 < else
6359 <  _somian_kspb_perl=`echo "$_somian_shbangperl" | sed -ne"s|.*='\($negclass*\)';$|\1|p"`
6360 <        if test "x$_somian_kspb_perl" == x
6361 <          then _somian_ksbp_warn_empty='durnit'
6362 <          else
6363 <          case "A$_somian_kspb_perl" in
6364 <                 A#!*perl* )
6365 <           ac_cv_sys_kernshrpbang_perl=`echo "$_somian_kspb_perl" | sed -e's|#!\(.*\)$|\1|'`
6366 <                        ;;
6367 <                     A*    )  _somian_ksbp_warn_defau='trouble'
6368 <                              ac_cv_sys_kernshrpbang_perl="$PERLINTERP"
6369 <          esac
6370 <        fi
6371 <
6372 < fi
6373 < { echo "$as_me:$LINENO: result: $ac_cv_sys_kernshrpbang_perl" >&5
6374 < echo "${ECHO_T}$ac_cv_sys_kernshrpbang_perl" >&6; }
6375 < # The above prints Checking ... result message to user.
6376 <   PERL_SHEBANG="$ac_cv_sys_kernshrpbang_perl"
6377 <
6378 <    if test A${_somian_ksbp_warn_empty+set} == Aset
6379 <      then   { echo "$as_me:$LINENO: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&5
6380 < echo "$as_me: WARNING: In last check, doing $PERLINTERP -V:startperl yielded empty result! That should not happen." >&2;}
6381 <    fi
6382 < # Inform user after printing result value
6383 <    if test A${_somian_ksbp_warn_defau+set} == Aset
6384 <      then { echo "$as_me:$LINENO: Maybe Not good -" >&5
6385 < echo "$as_me: Maybe Not good -" >&6;}
6386 <           { echo "$as_me:$LINENO: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&5
6387 < echo "$as_me: WARNING: In last check perl's Config query did not work so we bunted: $_sHpB$PERLINTERP" >&2;}
6388 <      else { echo "$as_me:$LINENO: OK Good result - " >&5
6389 < echo "$as_me: OK Good result - " >&6;}
6390 <           { echo "$as_me:$LINENO: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&5
6391 < echo "$as_me: In last check we got a proper-looking answer from perl's Config: $_somian_shbangperl" >&6;}
6392 <    fi
6393 <  fi
6394 <
6395 < # Find a good install program.  We prefer a C program (faster),
6396 < # so one script is as good as another.  But avoid the broken or
6397 < # incompatible versions:
6398 < # SysV /etc/install, /usr/sbin/install
6399 < # SunOS /usr/etc/install
6400 < # IRIX /sbin/install
6401 < # AIX /bin/install
6402 < # AmigaOS /C/install, which installs bootblocks on floppy discs
6403 < # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
6404 < # AFS /usr/afsws/bin/install, which mishandles nonexistent args
6405 < # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
6406 < # OS/2's system install, which has a completely different semantic
6407 < # ./install, which can be erroneously created by make from ./install.sh.
6408 < { echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
6409 < echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6; }
6410 < if test -z "$INSTALL"; then
6411 < if test "${ac_cv_path_install+set}" = set; then
6412 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6413 < else
6414 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6415 < for as_dir in $PATH
6416 < do
6417 <  IFS=$as_save_IFS
6418 <  test -z "$as_dir" && as_dir=.
6419 <  # Account for people who put trailing slashes in PATH elements.
6420 < case $as_dir/ in
6421 <  ./ | .// | /cC/* | \
6422 <  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
6423 <  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
6424 <  /usr/ucb/* ) ;;
6425 <  *)
6426 <    # OSF1 and SCO ODT 3.0 have their own names for install.
6427 <    # Don't use installbsd from OSF since it installs stuff as root
6428 <    # by default.
6429 <    for ac_prog in ginstall scoinst install; do
6430 <      for ac_exec_ext in '' $ac_executable_extensions; do
6431 <        if { test -f "$as_dir/$ac_prog$ac_exec_ext" && $as_test_x "$as_dir/$ac_prog$ac_exec_ext"; }; then
6432 <          if test $ac_prog = install &&
6433 <            grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6434 <            # AIX install.  It has an incompatible calling convention.
6435 <            :
6436 <          elif test $ac_prog = install &&
6437 <            grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
6438 <            # program-specific install script used by HP pwplus--don't use.
6439 <            :
6440 <          else
6441 <            ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
6442 <            break 3
6443 <          fi
6444 <        fi
6445 <      done
6446 <    done
6447 <    ;;
6448 < esac
6449 < done
6450 < IFS=$as_save_IFS
6451 <
6452 <
6453 < fi
6454 <  if test "${ac_cv_path_install+set}" = set; then
6455 <    INSTALL=$ac_cv_path_install
6456 <  else
6457 <    # As a last resort, use the slow shell script.  Don't cache a
6458 <    # value for INSTALL within a source directory, because that will
6459 <    # break other packages using the cache if that directory is
6460 <    # removed, or if the value is a relative name.
6461 <    INSTALL=$ac_install_sh
6462 <  fi
6463 < fi
6464 < { echo "$as_me:$LINENO: result: $INSTALL" >&5
6465 < echo "${ECHO_T}$INSTALL" >&6; }
6466 <
6467 < # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
6468 < # It thinks the first close brace ends the variable substitution.
6469 < test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
6470 <
6471 < test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
6472 <
6473 < test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
6474 <
6475 < case "x$INSTALL" in
6476 <   x/*) ;;
6477 <   *) INSTALL=`pwd`/ac-tools/"shtool install -c" ;
6478 < esac
6479 < MKINSTALLDIRS=`pwd`/ac-tools/"shtool mkdir -p -f"
6480 < # Extract the first word of "ar", so it can be a program name with args.
6481 < set dummy ar; ac_word=$2
6482 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
6483 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
6484 < if test "${ac_cv_prog_AR+set}" = set; then
6485 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6486 < else
6487 <  if test -n "$AR"; then
6488 <  ac_cv_prog_AR="$AR" # Let the user override the test.
6489 < else
6490 < as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6491 < for as_dir in $PATH
6492 < do
6493 <  IFS=$as_save_IFS
6494 <  test -z "$as_dir" && as_dir=.
6495 <  for ac_exec_ext in '' $ac_executable_extensions; do
6496 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6497 <    ac_cv_prog_AR="ar"
6498 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6499 <    break 2
6500 <  fi
6501 < done
6502 < done
6503 < IFS=$as_save_IFS
6504 <
6505 <  test -z "$ac_cv_prog_AR" && ac_cv_prog_AR="NONE"
6506 < fi
6507 < fi
6508 < AR=$ac_cv_prog_AR
6509 < if test -n "$AR"; then
6510 <  { echo "$as_me:$LINENO: result: $AR" >&5
6511 < echo "${ECHO_T}$AR" >&6; }
6512 < else
6513 <  { echo "$as_me:$LINENO: result: no" >&5
6514 < echo "${ECHO_T}no" >&6; }
6515 < fi
6516 <
6517 <
6518 < if test "$AR" = "NONE"; then
6519 <  cat >confcache <<\_ACEOF
6520 < # This file is a shell script that caches the results of configure
6521 < # tests run on this system so they can be shared between configure
6522 < # scripts and configure runs, see configure's option --config-cache.
6523 < # It is not useful on other systems.  If it contains results you don't
6524 < # want to keep, you may remove or edit it.
6525 < #
6526 < # config.status only pays attention to the cache file if you give it
6527 < # the --recheck option to rerun configure.
6528 < #
6529 < # `ac_cv_env_foo' variables (set or unset) will be overridden when
6530 < # loading this file, other *unset* `ac_cv_foo' will be assigned the
6531 < # following values.
6532 <
6533 < _ACEOF
6534 <
6535 < # The following way of writing the cache mishandles newlines in values,
6536 < # but we know of no workaround that is simple, portable, and efficient.
6537 < # So, we kill variables containing newlines.
6538 < # Ultrix sh set writes to stderr and can't be redirected directly,
6539 < # and sets the high bit in the cache file unless we assign to the vars.
6540 < (
6541 <  for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do
6542 <    eval ac_val=\$$ac_var
6543 <    case $ac_val in #(
6544 <    *${as_nl}*)
6545 <      case $ac_var in #(
6546 <      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
6547 < echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
6548 <      esac
6549 <      case $ac_var in #(
6550 <      _ | IFS | as_nl) ;; #(
6551 <      *) $as_unset $ac_var ;;
6552 <      esac ;;
6553 <    esac
6554 <  done
6555 <
6556 <  (set) 2>&1 |
6557 <    case $as_nl`(ac_space=' '; set) 2>&1` in #(
6558 <    *${as_nl}ac_space=\ *)
6559 <      # `set' does not quote correctly, so add quotes (double-quote
6560 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
6561 <      sed -n \
6562 <        "s/'/'\\\\''/g;
6563 <          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
6564 <      ;; #(
6565 <    *)
6566 <      # `set' quotes correctly as required by POSIX, so do not add quotes.
6567 <      sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
6568 <      ;;
6569 <    esac |
6570 <    sort
6571 < ) |
6572 <  sed '
6573 <     /^ac_cv_env_/b end
6574 <     t clear
6575 <     :clear
6576 <     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
6577 <     t end
6578 <     s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
6579 <     :end' >>confcache
6580 < if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
6581 <  if test -w "$cache_file"; then
6582 <    test "x$cache_file" != "x/dev/null" &&
6583 <      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
6584 < echo "$as_me: updating cache $cache_file" >&6;}
6585 <    cat confcache >$cache_file
6586 <  else
6587 <    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
6588 < echo "$as_me: not updating unwritable cache $cache_file" >&6;}
6589 <  fi
6590 < fi
6591 < rm -f confcache
6592 <  exit 1
6593 < fi
6594 < # Extract the first word of "ps", so it can be a program name with args.
6595 < set dummy ps; ac_word=$2
6596 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
6597 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
6598 < if test "${ac_cv_path_PS+set}" = set; then
6599 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6600 < else
6601 <  case $PS in
6602 <  [\\/]* | ?:[\\/]*)
6603 <  ac_cv_path_PS="$PS" # Let the user override the test with a path.
6604 <  ;;
6605 <  *)
6606 <  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6607 < for as_dir in $PATH
6608 < do
6609 <  IFS=$as_save_IFS
6610 <  test -z "$as_dir" && as_dir=.
6611 <  for ac_exec_ext in '' $ac_executable_extensions; do
6612 <  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
6613 <    ac_cv_path_PS="$as_dir/$ac_word$ac_exec_ext"
6614 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6615 <    break 2
6616 <  fi
6617 < done
6618 < done
6619 < IFS=$as_save_IFS
6620 <
6621 <  ;;
6622 < esac
6623 < fi
6624 < PS=$ac_cv_path_PS
6625 < if test -n "$PS"; then
6626 <  { echo "$as_me:$LINENO: result: $PS" >&5
6627 < echo "${ECHO_T}$PS" >&6; }
6628 < else
6629 <  { echo "$as_me:$LINENO: result: no" >&5
6630 < echo "${ECHO_T}no" >&6; }
6631 < fi
6632 <
6633 <
6634 < { echo "$as_me:$LINENO: checking for POSIX or BSD ps syntax" >&5
6635 < echo $ECHO_N "checking for POSIX or BSD ps syntax... $ECHO_C" >&6; }
6636 < if test "${ac_cv_prog_ps_syntax+set}" = set; then
6637 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6638 < else
6639 <
6640 <        if $PS ax -o rss > /dev/null 2>&1; then
6641 <                ac_cv_prog_ps_ax=yes
6642 <        else
6643 <                ac_cv_prog_ps_ax=no
6644 <        fi
6645 <        if $PS -ef -o rss > /dev/null 2>&1; then
6646 <                ac_cv_prog_ps_ef=yes
6647 <        else
6648 <                ac_cv_prog_ps_ef=no
6649 <        fi
6650 <        if test "$ac_cv_prog_ps_ax" = yes; then
6651 <                ac_cv_prog_ps_syntax=BSD
6652 <        else
6653 <                if test "$ac_cv_prog_ps_ef" = yes; then
6654 <                        ac_cv_prog_ps_syntax=POSIX
6655 <                else
6656 <                        { { echo "$as_me:$LINENO: error: Could not determine ps syntax" >&5
6657 < echo "$as_me: error: Could not determine ps syntax" >&2;}
6658 <   { (exit 1); exit 1; }; }
6659 <                fi
6660 <        fi
6661 <
6662 < fi
6663 < { echo "$as_me:$LINENO: result: $ac_cv_prog_ps_syntax" >&5
6664 < echo "${ECHO_T}$ac_cv_prog_ps_syntax" >&6; }
6665 <
6666 < cat >>confdefs.h <<_ACEOF
6667 < #define PSCOMMAND $PS
6668 < _ACEOF
6669 <
6670 < if test "$ac_cv_prog_ps_syntax" = BSD; then
6671 <
6672 < cat >>confdefs.h <<\_ACEOF
6673 < #define PSTYPE_IS_BSD 1
6674 < _ACEOF
6675 <
6676 < else
6677 <   if test "$ac_cv_prog_ps_syntax" = POSIX; then
6678 <
6679 < cat >>confdefs.h <<\_ACEOF
6680 < #define PSTYPE_IS_POSIX 1
6681 < _ACEOF
6682 <
6683 <   else
6684 <       { { echo "$as_me:$LINENO: error: Unknown ps syntax type!" >&5
6685 < echo "$as_me: error: Unknown ps syntax type!" >&2;}
6686 <   { (exit 1); exit 1; }; }
6687 <   fi
6688 < fi
6689 <
6690 < ac_ext=${ac_fc_srcext-f}
6691 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6692 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6693 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6694 <
6695 <
6696 < ac_ext=${ac_fc_srcext-f}
6697 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6698 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6699 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6700 < { echo "$as_me:$LINENO: checking for Fortran flag to compile .F90 files" >&5
6701 < echo $ECHO_N "checking for Fortran flag to compile .F90 files... $ECHO_C" >&6; }
6702 < if test "${ac_cv_fc_srcext_F90+set}" = set; then
6703 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6704 < else
6705 <  ac_ext=F90
6706 < ac_fcflags_srcext_save=$ac_fcflags_srcext
6707 < ac_fcflags_srcext=
6708 < ac_cv_fc_srcext_F90=unknown
6709 < for ac_flag in none -qsuffix=f=F90 -Tf; do
6710 <  test "x$ac_flag" != xnone && ac_fcflags_srcext="$ac_flag"
6711 <  cat >conftest.$ac_ext <<_ACEOF
6712 <      program main
6713 <
6714 <      end
6715 < _ACEOF
6716 < rm -f conftest.$ac_objext
6717 < if { (ac_try="$ac_compile"
6718 < case "(($ac_try" in
6719 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6720 <  *) ac_try_echo=$ac_try;;
6721 < esac
6722 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6723 <  (eval "$ac_compile") 2>conftest.er1
6724 <  ac_status=$?
6725 <  grep -v '^ *+' conftest.er1 >conftest.err
6726 <  rm -f conftest.er1
5576 <  cat conftest.err >&5
5577 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5578 <  (exit $ac_status); } && {
5579 <         test -z "$ac_fc_werror_flag" ||
5580 <         test ! -s conftest.err
5581 <       } && test -s conftest.$ac_objext; then
5582 <  ac_cv_fc_srcext_F90=$ac_flag; break
5583 < else
5584 <  echo "$as_me: failed program was:" >&5
5585 < sed 's/^/| /' conftest.$ac_ext >&5
5586 <
5587 <
5588 < fi
5589 <
5590 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5591 < done
5592 < rm -f conftest.$ac_objext conftest.F90
5593 < ac_fcflags_srcext=$ac_fcflags_srcext_save
5594 <
5595 < fi
5596 < { echo "$as_me:$LINENO: result: $ac_cv_fc_srcext_F90" >&5
5597 < echo "${ECHO_T}$ac_cv_fc_srcext_F90" >&6; }
5598 < if test "x$ac_cv_fc_srcext_F90" = xunknown; then
5599 <  { { echo "$as_me:$LINENO: error: Fortran could not compile .F90 files" >&5
5600 < echo "$as_me: error: Fortran could not compile .F90 files" >&2;}
5601 <   { (exit 1); exit 1; }; }
5602 < else
5603 <  ac_fc_srcext=F90
5604 <  if test "x$ac_cv_fc_srcext_F90" = xnone; then
5605 <    ac_fcflags_srcext=""
5606 <    FCFLAGS_F90=""
5607 <  else
5608 <    ac_fcflags_srcext=$ac_cv_fc_srcext_F90
5609 <    FCFLAGS_F90=$ac_cv_fc_srcext_F90
5610 <  fi
5611 <
5612 <
5613 < fi
5614 < ac_ext=${ac_fc_srcext-f}
5615 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5616 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5617 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5618 <
5619 <
5620 <
5621 <
5622 <
5623 < # Try to determine native compiler flags that allow us to use F90 suffix
5624 < # for preprocessed f90 source.
5625 <
5626 < if test "$ac_test_PREPFLAG" != "set"; then
5627 <  PREPFLAG=""
5628 <  case "${host_cpu}-${host_os}" in
5629 <
5630 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5631 <                    PREPFLAG="-fpp1 "
5632 <                fi;;
5633 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
5634 <                    PREPFLAG="-qsuffix=cpp=F90 "
5635 <                fi;;
5636 <  *darwin*)
5637 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
5638 <                PREPFLAG="-qsuffix=cpp=F90 "
5639 <        fi;;
5640 <  esac
5641 <
5642 <  if test -z "$PREPFLAG"; then
5643 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPFLAG\"" >&5
5644 < echo "$as_me: WARNING: \"Using empty PREPFLAG\"" >&2;}
5645 <        PREPFLAG=""
5646 <  fi
5647 <
5648 <  { echo "$as_me:$LINENO: checking to make sure F90 preprocessor flag works" >&5
5649 < echo $ECHO_N "checking to make sure F90 preprocessor flag works... $ECHO_C" >&6; }
5650 <
5651 <  ac_ext=${ac_fc_srcext-f}
5652 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5653 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5654 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5655 <
5656 <  ac_save_ext=$ac_ext
5657 <  ac_ext=F90
5658 <  ac_save_FCFLAGS_SRCEXT=$FCFLAGS_SRCEXT
5659 <
5660 <  if test "$PREPFLAG"; then
5661 <  FCFLAGS_SRCEXT="${PREPFLAG}"
5662 < fi
5663 <
5664 <    cat >conftest.$ac_ext <<_ACEOF
5665 <
5666 <
5667 < program conftest
5668 <  integer :: i
5669 <  i = 1
5670 < end program conftest
5671 <
5672 < _ACEOF
5673 < rm -f conftest.$ac_objext
5674 < if { (ac_try="$ac_compile"
5675 < case "(($ac_try" in
5676 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5677 <  *) ac_try_echo=$ac_try;;
5678 < esac
5679 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5680 <  (eval "$ac_compile") 2>conftest.er1
5681 <  ac_status=$?
5682 <  grep -v '^ *+' conftest.er1 >conftest.err
5683 <  rm -f conftest.er1
5684 <  cat conftest.err >&5
5685 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5686 <  (exit $ac_status); } && {
5687 <         test -z "$ac_fc_werror_flag" ||
5688 <         test ! -s conftest.err
5689 <       } && test -s conftest.$ac_objext; then
5690 <  prepflagworks=1
5691 < else
5692 <  echo "$as_me: failed program was:" >&5
5693 < sed 's/^/| /' conftest.$ac_ext >&5
5694 <
5695 <        prepflagworks=0
5696 < fi
5697 <
5698 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5699 <
5700 <  FCFLAGS_SRCEXT=$ac_save_FCFLAGS_SRCEXT
5701 <  ac_ext=$ac_save_ext
5702 <  ac_ext=${ac_fc_srcext-f}
5703 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5704 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5705 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5706 <
5707 <
5708 <  if test "$prepflagworks" = 1; then
5709 <    { echo "$as_me:$LINENO: result: yes" >&5
5710 < echo "${ECHO_T}yes" >&6; }
5711 <    FCFLAGS_SRCEXT="${PREPFLAG}"
5712 <
5713 <  else
5714 <    { echo "$as_me:$LINENO: result: no" >&5
5715 < echo "${ECHO_T}no" >&6; }
5716 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor flag" >&5
5717 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor flag" >&2;}
5718 <   { (exit 1); exit 1; }; }
5719 <  fi
5720 < fi
5721 <
5722 <
5723 <
5724 <
5725 <
5726 < # Try to determine native compiler flags that allow us to use F90 suffix
5727 < # for preprocessed f90 source with -D type defines
5728 <
5729 < if test "$ac_test_PREPDEFFLAG" != "set"; then
5730 <  PREPDEFFLAG=""
5731 <  case "${host_cpu}-${host_os}" in
5732 <
5733 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
5734 <                    PREPDEFFLAG=" "
5735 <                fi;;
5736 <  *aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
5737 <                    PREPDEFFLAG="-WF,"
5738 <                fi;;
5739 <  *darwin*)
5740 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
5741 <                PREPDEFFLAG="-WF,"
5742 <        fi;;
5743 <  esac
5744 <
5745 <  if test -z "$PREPDEFFLAG"; then
5746 <        { echo "$as_me:$LINENO: WARNING: \"Using empty PREPDEFFLAG\"" >&5
5747 < echo "$as_me: WARNING: \"Using empty PREPDEFFLAG\"" >&2;}
5748 <        PREPDEFFLAG=" "
5749 <  fi
5750 <
5751 <  { echo "$as_me:$LINENO: checking to make sure F90 preprocessor define flag works" >&5
5752 < echo $ECHO_N "checking to make sure F90 preprocessor define flag works... $ECHO_C" >&6; }
5753 <
5754 <  ac_ext=${ac_fc_srcext-f}
5755 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5756 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5757 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5758 <
5759 <  ac_save_ext=$ac_ext
5760 <  ac_ext=F90
5761 <  ac_save_FCFLAGS=$FCFLAGS
5762 <
5763 <  if test "$PREPDEFFLAG"; then
5764 <  FCFLAGS="${FCFLAGS} ${PREPDEFFLAG}-DTEST"
5765 < fi
5766 <
5767 <    cat >conftest.$ac_ext <<_ACEOF
5768 <
5769 <
5770 < program conftest
5771 <  integer :: i
5772 < #ifdef TEST
5773 <  i = 1
5774 < #else
5775 <  choke me
5776 < #endif
5777 < end program conftest
5778 <
5779 < _ACEOF
5780 < rm -f conftest.$ac_objext
5781 < if { (ac_try="$ac_compile"
5782 < case "(($ac_try" in
5783 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5784 <  *) ac_try_echo=$ac_try;;
5785 < esac
5786 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5787 <  (eval "$ac_compile") 2>conftest.er1
5788 <  ac_status=$?
5789 <  grep -v '^ *+' conftest.er1 >conftest.err
5790 <  rm -f conftest.er1
5791 <  cat conftest.err >&5
5792 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5793 <  (exit $ac_status); } && {
5794 <         test -z "$ac_fc_werror_flag" ||
5795 <         test ! -s conftest.err
5796 <       } && test -s conftest.$ac_objext; then
5797 <  prepdefflagworks=1
5798 < else
5799 <  echo "$as_me: failed program was:" >&5
5800 < sed 's/^/| /' conftest.$ac_ext >&5
5801 <
5802 <        prepdefflagworks=0
5803 < fi
5804 <
5805 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5806 <
5807 <  FCFLAGS=$ac_save_FCFLAGS
5808 <  ac_ext=$ac_save_ext
5809 <  ac_ext=${ac_fc_srcext-f}
5810 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5811 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5812 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5813 <
5814 <
5815 <  if test "$prepdefflagworks" = 1; then
5816 <    { echo "$as_me:$LINENO: result: yes" >&5
5817 < echo "${ECHO_T}yes" >&6; }
5818 <
5819 <  else
5820 <    { echo "$as_me:$LINENO: result: no" >&5
5821 < echo "${ECHO_T}no" >&6; }
5822 <    { { echo "$as_me:$LINENO: error: Can't figure out working Fortran90 preprocessor define flag" >&5
5823 < echo "$as_me: error: Can't figure out working Fortran90 preprocessor define flag" >&2;}
5824 <   { (exit 1); exit 1; }; }
5825 <  fi
5826 < fi
5827 <
5828 < ac_ext=${ac_fc_srcext-f}
5829 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
5830 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
5831 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
5832 < { echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
5833 < echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6; }
5834 < if test "${ac_cv_prog_fc_v+set}" = set; then
5835 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5836 < else
5837 <  cat >conftest.$ac_ext <<_ACEOF
5838 <      program main
5839 <
5840 <      end
5841 < _ACEOF
5842 < rm -f conftest.$ac_objext
5843 < if { (ac_try="$ac_compile"
5844 < case "(($ac_try" in
5845 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
5846 <  *) ac_try_echo=$ac_try;;
5847 < esac
5848 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
5849 <  (eval "$ac_compile") 2>conftest.er1
5850 <  ac_status=$?
5851 <  grep -v '^ *+' conftest.er1 >conftest.err
5852 <  rm -f conftest.er1
5853 <  cat conftest.err >&5
5854 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5855 <  (exit $ac_status); } && {
5856 <         test -z "$ac_fc_werror_flag" ||
5857 <         test ! -s conftest.err
5858 <       } && test -s conftest.$ac_objext; then
5859 <  ac_cv_prog_fc_v=
5860 < # Try some options frequently used verbose output
5861 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
5862 <  cat >conftest.$ac_ext <<_ACEOF
5863 <      program main
5864 <
5865 <      end
5866 < _ACEOF
5867 <
5868 < # Compile and link our simple test program by passing a flag (argument
5869 < # 1 to this macro) to the Fortran compiler in order to get
5870 < # "verbose" output that we can then parse for the Fortran linker
5871 < # flags.
5872 < ac_save_FFLAGS=$FCFLAGS
5873 < FCFLAGS="$FCFLAGS $ac_verb"
5874 < eval "set x $ac_link"
5875 < shift
5876 < echo "$as_me:$LINENO: $*" >&5
5877 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5878 < echo "$ac_fc_v_output" >&5
5879 < FCFLAGS=$ac_save_FFLAGS
5880 <
5881 < rm -f conftest*
5882 <
5883 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5884 < # /foo, /bar, and /baz are search directories for the Fortran linker.
5885 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5886 < ac_fc_v_output="`echo $ac_fc_v_output |
5887 <        grep 'LPATH is:' |
5888 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5889 <
5890 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
5891 < #        that detects unbalanced quotes in FLIBS should be implemented
5892 < #        and (ugh) tested at some point.
5893 < case $ac_fc_v_output in
5894 <  # If we are using xlf then replace all the commas with spaces.
5895 <  *xlfentry*)
5896 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5897 <
5898 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5899 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
5900 <  *mGLOB_options_string*)
5901 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
5902 <
5903 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
5904 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
5905 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
5906 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
5907 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
5908 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
5909 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
5910 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
5911 <
5912 <  # If we are using Cray Fortran then delete quotes.
5913 <  *cft90*)
5914 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
5915 < esac
5916 <
5917 <
5918 <  # look for -l* and *.a constructs in the output
5919 <  for ac_arg in $ac_fc_v_output; do
5920 <     case $ac_arg in
5921 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
5922 <          ac_cv_prog_fc_v=$ac_verb
5923 <          break 2 ;;
5924 <     esac
5925 <  done
5926 < done
5927 < if test -z "$ac_cv_prog_fc_v"; then
5928 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
5929 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
5930 < fi
5931 < else
5932 <  echo "$as_me: failed program was:" >&5
5933 < sed 's/^/| /' conftest.$ac_ext >&5
5934 <
5935 <        { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
5936 < echo "$as_me: WARNING: compilation failed" >&2;}
5937 < fi
5938 <
5939 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
5940 <
5941 < fi
5942 < { echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
5943 < echo "${ECHO_T}$ac_cv_prog_fc_v" >&6; }
5944 < { echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
5945 < echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6; }
5946 < if test "${ac_cv_fc_libs+set}" = set; then
5947 <  echo $ECHO_N "(cached) $ECHO_C" >&6
5948 < else
5949 <  if test "x$FCLIBS" != "x"; then
5950 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
5951 < else
5952 <
5953 < cat >conftest.$ac_ext <<_ACEOF
5954 <      program main
5955 <
5956 <      end
5957 < _ACEOF
5958 <
5959 < # Compile and link our simple test program by passing a flag (argument
5960 < # 1 to this macro) to the Fortran compiler in order to get
5961 < # "verbose" output that we can then parse for the Fortran linker
5962 < # flags.
5963 < ac_save_FFLAGS=$FCFLAGS
5964 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
5965 < eval "set x $ac_link"
5966 < shift
5967 < echo "$as_me:$LINENO: $*" >&5
5968 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
5969 < echo "$ac_fc_v_output" >&5
5970 < FCFLAGS=$ac_save_FFLAGS
5971 <
5972 < rm -f conftest*
5973 <
5974 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
5975 < # /foo, /bar, and /baz are search directories for the Fortran linker.
5976 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
5977 < ac_fc_v_output="`echo $ac_fc_v_output |
5978 <        grep 'LPATH is:' |
5979 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
5980 <
5981 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
5982 < #        that detects unbalanced quotes in FLIBS should be implemented
5983 < #        and (ugh) tested at some point.
5984 < case $ac_fc_v_output in
5985 <  # If we are using xlf then replace all the commas with spaces.
5986 <  *xlfentry*)
5987 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
5988 <
5989 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
5990 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
5991 <  *mGLOB_options_string*)
5992 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
5993 <
5994 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
5995 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
5996 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
5997 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
5998 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
5999 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6000 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6001 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6002 <
6003 <  # If we are using Cray Fortran then delete quotes.
6004 <  *cft90*)
6005 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6006 < esac
6007 <
6008 <
6009 <
6010 < ac_cv_fc_libs=
6011 <
6012 < # Save positional arguments (if any)
6013 < ac_save_positional="$@"
6014 <
6015 < set X $ac_fc_v_output
6016 < while test $# != 1; do
6017 <  shift
6018 <  ac_arg=$1
6019 <  case $ac_arg in
6020 <        [\\/]*.a | ?:[\\/]*.a)
6021 <            ac_exists=false
6022 <  for ac_i in $ac_cv_fc_libs; do
6023 <    if test x"$ac_arg" = x"$ac_i"; then
6024 <      ac_exists=true
6025 <      break
6026 <    fi
6027 <  done
6028 <
6029 <  if test x"$ac_exists" = xtrue; then
6030 <  :
6031 < else
6032 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6033 < fi
6034 <
6035 <          ;;
6036 <        -bI:*)
6037 <            ac_exists=false
6038 <  for ac_i in $ac_cv_fc_libs; do
6039 <    if test x"$ac_arg" = x"$ac_i"; then
6040 <      ac_exists=true
6041 <      break
6042 <    fi
6043 <  done
6044 <
6045 <  if test x"$ac_exists" = xtrue; then
6046 <  :
6047 < else
6048 <  if test "$ac_compiler_gnu" = yes; then
6049 <  for ac_link_opt in $ac_arg; do
6050 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6051 <  done
6052 < else
6053 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6054 < fi
6055 < fi
6056 <
6057 <          ;;
6058 <          # Ignore these flags.
6059 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
6060 <          ;;
6061 <        -lkernel32)
6062 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6063 <          ;;
6064 <        -[LRuYz])
6065 <          # These flags, when seen by themselves, take an argument.
6066 <          # We remove the space between option and argument and re-iterate
6067 <          # unless we find an empty arg or a new option (starting with -)
6068 <          case $2 in
6069 <             "" | -*);;
6070 <             *)
6071 <                ac_arg="$ac_arg$2"
6072 <                shift; shift
6073 <                set X $ac_arg "$@"
6074 <                ;;
6075 <          esac
6076 <          ;;
6077 <        -YP,*)
6078 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
6079 <              ac_exists=false
6080 <  for ac_i in $ac_cv_fc_libs; do
6081 <    if test x"$ac_j" = x"$ac_i"; then
6082 <      ac_exists=true
6083 <      break
6084 <    fi
6085 <  done
6086 <
6087 <  if test x"$ac_exists" = xtrue; then
6088 <  :
6089 < else
6090 <  ac_arg="$ac_arg $ac_j"
6091 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
6092 < fi
6093 <
6094 <          done
6095 <          ;;
6096 <        -[lLR]*)
6097 <            ac_exists=false
6098 <  for ac_i in $ac_cv_fc_libs; do
6099 <    if test x"$ac_arg" = x"$ac_i"; then
6100 <      ac_exists=true
6101 <      break
6102 <    fi
6103 <  done
6104 <
6105 <  if test x"$ac_exists" = xtrue; then
6106 <  :
6107 < else
6108 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6109 < fi
6110 <
6111 <          ;;
6112 <        -zallextract*| -zdefaultextract)
6113 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6114 <          ;;
6115 <          # Ignore everything else.
6116 <  esac
6117 < done
6118 < # restore positional arguments
6119 < set X $ac_save_positional; shift
6120 <
6121 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
6122 < # then we insist that the "run path" must be an absolute path (i.e. it
6123 < # must begin with a "/").
6124 < case `(uname -sr) 2>/dev/null` in
6125 <   "SunOS 5"*)
6126 <      ac_ld_run_path=`echo $ac_fc_v_output |
6127 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
6128 <      test "x$ac_ld_run_path" != x &&
6129 <        if test "$ac_compiler_gnu" = yes; then
6130 <  for ac_link_opt in $ac_ld_run_path; do
6131 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6132 <  done
6133 < else
6134 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
6135 < fi
6136 <      ;;
6137 < esac
6138 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
6139 <
6140 < fi
6141 < { echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
6142 < echo "${ECHO_T}$ac_cv_fc_libs" >&6; }
6143 < FCLIBS="$ac_cv_fc_libs"
6144 <
6145 <
6146 < ac_ext=${ac_fc_srcext-f}
6147 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6148 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6149 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6150 <
6151 <
6152 < ac_ext=${ac_fc_srcext-f}
6153 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6154 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6155 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6156 <
6157 < { echo "$as_me:$LINENO: checking for dummy main to link with Fortran libraries" >&5
6158 < echo $ECHO_N "checking for dummy main to link with Fortran libraries... $ECHO_C" >&6; }
6159 < if test "${ac_cv_fc_dummy_main+set}" = set; then
6160 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6161 < else
6162 <  ac_fc_dm_save_LIBS=$LIBS
6163 < LIBS="$LIBS $FCLIBS"
6164 < ac_fortran_dm_var=FC_DUMMY_MAIN
6165 < ac_ext=c
6166 < ac_cpp='$CPP $CPPFLAGS'
6167 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6168 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6169 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6170 <
6171 < # First, try linking without a dummy main:
6172 < cat >conftest.$ac_ext <<_ACEOF
6173 < /* confdefs.h.  */
6174 < _ACEOF
6175 < cat confdefs.h >>conftest.$ac_ext
6176 < cat >>conftest.$ac_ext <<_ACEOF
6177 < /* end confdefs.h.  */
6178 <
6179 < #ifdef FC_DUMMY_MAIN
6180 < #ifndef FC_DUMMY_MAIN_EQ_F77
6181 < #  ifdef __cplusplus
6182 <     extern "C"
6183 < #  endif
6184 <   int FC_DUMMY_MAIN() { return 1; }
6185 < #endif
6186 < #endif
6187 < int
6188 < main ()
6189 < {
6190 <
6191 <  ;
6192 <  return 0;
6193 < }
6194 < _ACEOF
6195 < rm -f conftest.$ac_objext conftest$ac_exeext
6196 < if { (ac_try="$ac_link"
6197 < case "(($ac_try" in
6198 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6199 <  *) ac_try_echo=$ac_try;;
6200 < esac
6201 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6202 <  (eval "$ac_link") 2>conftest.er1
6203 <  ac_status=$?
6204 <  grep -v '^ *+' conftest.er1 >conftest.err
6205 <  rm -f conftest.er1
6206 <  cat conftest.err >&5
6207 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6208 <  (exit $ac_status); } && {
6209 <         test -z "$ac_c_werror_flag" ||
6210 <         test ! -s conftest.err
6211 <       } && test -s conftest$ac_exeext &&
6212 <       $as_test_x conftest$ac_exeext; then
6213 <  ac_cv_fortran_dummy_main=none
6214 < else
6215 <  echo "$as_me: failed program was:" >&5
6216 < sed 's/^/| /' conftest.$ac_ext >&5
6217 <
6218 <        ac_cv_fortran_dummy_main=unknown
6219 < fi
6220 <
6221 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6222 <      conftest$ac_exeext conftest.$ac_ext
6223 <
6224 < if test $ac_cv_fortran_dummy_main = unknown; then
6225 <   for ac_func in MAIN__ MAIN_ __main MAIN _MAIN __MAIN main_ main__ _main; do
6226 <     cat >conftest.$ac_ext <<_ACEOF
6227 < /* confdefs.h.  */
6228 < _ACEOF
6229 < cat confdefs.h >>conftest.$ac_ext
6230 < cat >>conftest.$ac_ext <<_ACEOF
6231 < /* end confdefs.h.  */
6232 < #define $ac_fortran_dm_var $ac_func
6233 < #ifdef FC_DUMMY_MAIN
6234 < #ifndef FC_DUMMY_MAIN_EQ_F77
6235 < #  ifdef __cplusplus
6236 <     extern "C"
6237 < #  endif
6238 <   int FC_DUMMY_MAIN() { return 1; }
6239 < #endif
6240 < #endif
6241 < int
6242 < main ()
6243 < {
6244 <
6245 <  ;
6246 <  return 0;
6247 < }
6248 < _ACEOF
6249 < rm -f conftest.$ac_objext conftest$ac_exeext
6250 < if { (ac_try="$ac_link"
6251 < case "(($ac_try" in
6252 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6253 <  *) ac_try_echo=$ac_try;;
6254 < esac
6255 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6256 <  (eval "$ac_link") 2>conftest.er1
6257 <  ac_status=$?
6258 <  grep -v '^ *+' conftest.er1 >conftest.err
6259 <  rm -f conftest.er1
6260 <  cat conftest.err >&5
6261 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6262 <  (exit $ac_status); } && {
6263 <         test -z "$ac_c_werror_flag" ||
6264 <         test ! -s conftest.err
6265 <       } && test -s conftest$ac_exeext &&
6266 <       $as_test_x conftest$ac_exeext; then
6267 <  ac_cv_fortran_dummy_main=$ac_func; break
6268 < else
6269 <  echo "$as_me: failed program was:" >&5
6270 < sed 's/^/| /' conftest.$ac_ext >&5
6271 <
6272 <
6273 < fi
6274 <
6275 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6276 <      conftest$ac_exeext conftest.$ac_ext
6277 <   done
6278 < fi
6279 < ac_ext=${ac_fc_srcext-f}
6280 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6281 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6282 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6283 < ac_cv_fc_dummy_main=$ac_cv_fortran_dummy_main
6284 < rm -f conftest*
6285 < LIBS=$ac_fc_dm_save_LIBS
6286 <
6287 < fi
6288 < { echo "$as_me:$LINENO: result: $ac_cv_fc_dummy_main" >&5
6289 < echo "${ECHO_T}$ac_cv_fc_dummy_main" >&6; }
6290 < FC_DUMMY_MAIN=$ac_cv_fc_dummy_main
6291 < if test "$FC_DUMMY_MAIN" != unknown; then
6292 <  if test $FC_DUMMY_MAIN != none; then
6293 <
6294 < cat >>confdefs.h <<_ACEOF
6295 < #define FC_DUMMY_MAIN $FC_DUMMY_MAIN
6296 < _ACEOF
6297 <
6298 <  if test "x$ac_cv_fc_dummy_main" = "x$ac_cv_f77_dummy_main"; then
6299 <
6300 < cat >>confdefs.h <<\_ACEOF
6301 < #define FC_DUMMY_MAIN_EQ_F77 1
6302 < _ACEOF
6303 <
6304 <  fi
6305 < fi
6306 < else
6307 <  { { echo "$as_me:$LINENO: error: linking to Fortran libraries from C fails
6308 < See \`config.log' for more details." >&5
6309 < echo "$as_me: error: linking to Fortran libraries from C fails
6310 < See \`config.log' for more details." >&2;}
6311 <   { (exit 1); exit 1; }; }
6312 < fi
6313 <
6314 <
6315 < ac_ext=${ac_fc_srcext-f}
6316 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6317 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6318 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6319 <
6320 < ac_ext=${ac_fc_srcext-f}
6321 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6322 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6323 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6324 < { echo "$as_me:$LINENO: checking for Fortran name-mangling scheme" >&5
6325 < echo $ECHO_N "checking for Fortran name-mangling scheme... $ECHO_C" >&6; }
6326 < if test "${ac_cv_fc_mangling+set}" = set; then
6327 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6328 < else
6329 <  cat >conftest.$ac_ext <<_ACEOF
6330 <      subroutine foobar()
6331 <      return
6332 <      end
6333 <      subroutine foo_bar()
6334 <      return
6335 <      end
6336 < _ACEOF
6337 < rm -f conftest.$ac_objext
6338 < if { (ac_try="$ac_compile"
6339 < case "(($ac_try" in
6340 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6341 <  *) ac_try_echo=$ac_try;;
6342 < esac
6343 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6344 <  (eval "$ac_compile") 2>conftest.er1
6345 <  ac_status=$?
6346 <  grep -v '^ *+' conftest.er1 >conftest.err
6347 <  rm -f conftest.er1
6348 <  cat conftest.err >&5
6349 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6350 <  (exit $ac_status); } && {
6351 <         test -z "$ac_fc_werror_flag" ||
6352 <         test ! -s conftest.err
6353 <       } && test -s conftest.$ac_objext; then
6354 <  mv conftest.$ac_objext cfortran_test.$ac_objext
6355 <
6356 <  ac_save_LIBS=$LIBS
6357 <  LIBS="cfortran_test.$ac_objext $LIBS $FCLIBS"
6358 <
6359 <  ac_ext=c
6360 < ac_cpp='$CPP $CPPFLAGS'
6361 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6362 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6363 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6364 <  ac_success=no
6365 <  for ac_foobar in foobar FOOBAR; do
6366 <    for ac_underscore in "" "_"; do
6367 <      ac_func="$ac_foobar$ac_underscore"
6368 <      cat >conftest.$ac_ext <<_ACEOF
6369 < /* confdefs.h.  */
6370 < _ACEOF
6371 < cat confdefs.h >>conftest.$ac_ext
6372 < cat >>conftest.$ac_ext <<_ACEOF
6373 < /* end confdefs.h.  */
6374 <
6375 < /* Override any GCC internal prototype to avoid an error.
6376 <   Use char because int might match the return type of a GCC
6377 <   builtin and then its argument prototype would still apply.  */
6378 < #ifdef __cplusplus
6379 < extern "C"
6380 < #endif
6381 < char $ac_func ();
6382 < #ifdef FC_DUMMY_MAIN
6383 < #ifndef FC_DUMMY_MAIN_EQ_F77
6384 < #  ifdef __cplusplus
6385 <     extern "C"
6386 < #  endif
6387 <   int FC_DUMMY_MAIN() { return 1; }
6388 < #endif
6389 < #endif
6390 < int
6391 < main ()
6392 < {
6393 < return $ac_func ();
6394 <  ;
6395 <  return 0;
6396 < }
6397 < _ACEOF
6398 < rm -f conftest.$ac_objext conftest$ac_exeext
6399 < if { (ac_try="$ac_link"
6400 < case "(($ac_try" in
6401 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6402 <  *) ac_try_echo=$ac_try;;
6403 < esac
6404 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6405 <  (eval "$ac_link") 2>conftest.er1
6406 <  ac_status=$?
6407 <  grep -v '^ *+' conftest.er1 >conftest.err
6408 <  rm -f conftest.er1
6409 <  cat conftest.err >&5
6410 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6411 <  (exit $ac_status); } && {
6412 <         test -z "$ac_c_werror_flag" ||
6413 <         test ! -s conftest.err
6414 <       } && test -s conftest$ac_exeext &&
6415 <       $as_test_x conftest$ac_exeext; then
6416 <  ac_success=yes; break 2
6417 < else
6418 <  echo "$as_me: failed program was:" >&5
6419 < sed 's/^/| /' conftest.$ac_ext >&5
6420 <
6421 <
6422 < fi
6423 <
6424 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6425 <      conftest$ac_exeext conftest.$ac_ext
6426 <    done
6427 <  done
6428 <  ac_ext=${ac_fc_srcext-f}
6429 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6430 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6431 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6432 <
6433 <  if test "$ac_success" = "yes"; then
6434 <     case $ac_foobar in
6435 <        foobar)
6436 <           ac_case=lower
6437 <           ac_foo_bar=foo_bar
6438 <           ;;
6439 <        FOOBAR)
6440 <           ac_case=upper
6441 <           ac_foo_bar=FOO_BAR
6442 <           ;;
6443 <     esac
6444 <
6445 <     ac_ext=c
6446 < ac_cpp='$CPP $CPPFLAGS'
6447 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
6448 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
6449 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
6450 <     ac_success_extra=no
6451 <     for ac_extra in "" "_"; do
6452 <        ac_func="$ac_foo_bar$ac_underscore$ac_extra"
6453 <        cat >conftest.$ac_ext <<_ACEOF
6454 < /* confdefs.h.  */
6455 < _ACEOF
6456 < cat confdefs.h >>conftest.$ac_ext
6457 < cat >>conftest.$ac_ext <<_ACEOF
6458 < /* end confdefs.h.  */
6459 <
6460 < /* Override any GCC internal prototype to avoid an error.
6461 <   Use char because int might match the return type of a GCC
6462 <   builtin and then its argument prototype would still apply.  */
6463 < #ifdef __cplusplus
6464 < extern "C"
6465 < #endif
6466 < char $ac_func ();
6467 < #ifdef FC_DUMMY_MAIN
6468 < #ifndef FC_DUMMY_MAIN_EQ_F77
6469 < #  ifdef __cplusplus
6470 <     extern "C"
6471 < #  endif
6472 <   int FC_DUMMY_MAIN() { return 1; }
6473 < #endif
6474 < #endif
6475 < int
6476 < main ()
6477 < {
6478 < return $ac_func ();
6479 <  ;
6480 <  return 0;
6481 < }
6482 < _ACEOF
6483 < rm -f conftest.$ac_objext conftest$ac_exeext
6484 < if { (ac_try="$ac_link"
6485 < case "(($ac_try" in
6486 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6487 <  *) ac_try_echo=$ac_try;;
6488 < esac
6489 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6490 <  (eval "$ac_link") 2>conftest.er1
6491 <  ac_status=$?
6492 <  grep -v '^ *+' conftest.er1 >conftest.err
6493 <  rm -f conftest.er1
6494 <  cat conftest.err >&5
6495 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6496 <  (exit $ac_status); } && {
6497 <         test -z "$ac_c_werror_flag" ||
6498 <         test ! -s conftest.err
6499 <       } && test -s conftest$ac_exeext &&
6500 <       $as_test_x conftest$ac_exeext; then
6501 <  ac_success_extra=yes; break
6502 < else
6503 <  echo "$as_me: failed program was:" >&5
6504 < sed 's/^/| /' conftest.$ac_ext >&5
6505 <
6506 <
6507 < fi
6508 <
6509 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6510 <      conftest$ac_exeext conftest.$ac_ext
6511 <     done
6512 <     ac_ext=${ac_fc_srcext-f}
6513 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6514 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6515 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6516 <
6517 <     if test "$ac_success_extra" = "yes"; then
6518 <        ac_cv_fc_mangling="$ac_case case"
6519 <        if test -z "$ac_underscore"; then
6520 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no underscore"
6521 <        else
6522 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, underscore"
6523 <        fi
6524 <        if test -z "$ac_extra"; then
6525 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, no extra underscore"
6526 <        else
6527 <           ac_cv_fc_mangling="$ac_cv_fc_mangling, extra underscore"
6528 <        fi
6529 <      else
6530 <        ac_cv_fc_mangling="unknown"
6531 <      fi
6532 <  else
6533 <     ac_cv_fc_mangling="unknown"
6534 <  fi
6535 <
6536 <  LIBS=$ac_save_LIBS
6537 <  rm -f cfortran_test* conftest*
6538 < else
6539 <  echo "$as_me: failed program was:" >&5
6540 < sed 's/^/| /' conftest.$ac_ext >&5
6541 <
6542 <        { { echo "$as_me:$LINENO: error: cannot compile a simple Fortran program
6543 < See \`config.log' for more details." >&5
6544 < echo "$as_me: error: cannot compile a simple Fortran program
6545 < See \`config.log' for more details." >&2;}
6546 <   { (exit 1); exit 1; }; }
6547 < fi
6548 <
6549 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6550 <
6551 < fi
6552 < { echo "$as_me:$LINENO: result: $ac_cv_fc_mangling" >&5
6553 < echo "${ECHO_T}$ac_cv_fc_mangling" >&6; }
6554 <
6555 < ac_ext=${ac_fc_srcext-f}
6556 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6557 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6558 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6559 <
6560 < ac_ext=${ac_fc_srcext-f}
6561 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6562 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6563 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6564 <
6565 <
6566 < case $ac_cv_fc_mangling in
6567 <  "lower case, no underscore, no extra underscore")
6568 <          cat >>confdefs.h <<\_ACEOF
6569 < #define FC_FUNC(name,NAME) name
6570 < _ACEOF
6571 <
6572 <          cat >>confdefs.h <<\_ACEOF
6573 < #define FC_FUNC_(name,NAME) name
6574 < _ACEOF
6575 < ;;
6576 <  "lower case, no underscore, extra underscore")
6577 <          cat >>confdefs.h <<\_ACEOF
6578 < #define FC_FUNC(name,NAME) name
6579 < _ACEOF
6580 <
6581 <          cat >>confdefs.h <<\_ACEOF
6582 < #define FC_FUNC_(name,NAME) name ## _
6583 < _ACEOF
6584 < ;;
6585 <  "lower case, underscore, no extra underscore")
6586 <          cat >>confdefs.h <<\_ACEOF
6587 < #define FC_FUNC(name,NAME) name ## _
6588 < _ACEOF
6589 <
6590 <          cat >>confdefs.h <<\_ACEOF
6591 < #define FC_FUNC_(name,NAME) name ## _
6592 < _ACEOF
6593 < ;;
6594 <  "lower case, underscore, extra underscore")
6595 <          cat >>confdefs.h <<\_ACEOF
6596 < #define FC_FUNC(name,NAME) name ## _
6597 < _ACEOF
6598 <
6599 <          cat >>confdefs.h <<\_ACEOF
6600 < #define FC_FUNC_(name,NAME) name ## __
6601 < _ACEOF
6602 < ;;
6603 <  "upper case, no underscore, no extra underscore")
6604 <          cat >>confdefs.h <<\_ACEOF
6605 < #define FC_FUNC(name,NAME) NAME
6606 < _ACEOF
6607 <
6608 <          cat >>confdefs.h <<\_ACEOF
6609 < #define FC_FUNC_(name,NAME) NAME
6610 < _ACEOF
6611 < ;;
6612 <  "upper case, no underscore, extra underscore")
6613 <          cat >>confdefs.h <<\_ACEOF
6614 < #define FC_FUNC(name,NAME) NAME
6615 < _ACEOF
6616 <
6617 <          cat >>confdefs.h <<\_ACEOF
6618 < #define FC_FUNC_(name,NAME) NAME ## _
6619 < _ACEOF
6620 < ;;
6621 <  "upper case, underscore, no extra underscore")
6622 <          cat >>confdefs.h <<\_ACEOF
6623 < #define FC_FUNC(name,NAME) NAME ## _
6624 < _ACEOF
6625 <
6626 <          cat >>confdefs.h <<\_ACEOF
6627 < #define FC_FUNC_(name,NAME) NAME ## _
6628 < _ACEOF
6629 < ;;
6630 <  "upper case, underscore, extra underscore")
6631 <          cat >>confdefs.h <<\_ACEOF
6632 < #define FC_FUNC(name,NAME) NAME ## _
6633 < _ACEOF
6634 <
6635 <          cat >>confdefs.h <<\_ACEOF
6636 < #define FC_FUNC_(name,NAME) NAME ## __
6637 < _ACEOF
6638 < ;;
6639 <  *)
6640 <          { echo "$as_me:$LINENO: WARNING: unknown Fortran name-mangling scheme" >&5
6641 < echo "$as_me: WARNING: unknown Fortran name-mangling scheme" >&2;}
6642 <          ;;
6643 < esac
6644 <
6645 < ac_ext=${ac_fc_srcext-f}
6646 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6647 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6648 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6649 <
6650 <
6651 <
6652 < ac_ext=${ac_fc_srcext-f}
6653 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6654 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6655 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6656 < { echo "$as_me:$LINENO: checking how to get verbose linking output from $FC" >&5
6657 < echo $ECHO_N "checking how to get verbose linking output from $FC... $ECHO_C" >&6; }
6658 < if test "${ac_cv_prog_fc_v+set}" = set; then
6659 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6660 < else
6661 <  cat >conftest.$ac_ext <<_ACEOF
6662 <      program main
6663 <
6664 <      end
6665 < _ACEOF
6666 < rm -f conftest.$ac_objext
6667 < if { (ac_try="$ac_compile"
6668 < case "(($ac_try" in
6669 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6670 <  *) ac_try_echo=$ac_try;;
6671 < esac
6672 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6673 <  (eval "$ac_compile") 2>conftest.er1
6674 <  ac_status=$?
6675 <  grep -v '^ *+' conftest.er1 >conftest.err
6676 <  rm -f conftest.er1
6677 <  cat conftest.err >&5
6678 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6679 <  (exit $ac_status); } && {
6680 <         test -z "$ac_fc_werror_flag" ||
6681 <         test ! -s conftest.err
6682 <       } && test -s conftest.$ac_objext; then
6683 <  ac_cv_prog_fc_v=
6684 < # Try some options frequently used verbose output
6685 < for ac_verb in -v -verbose --verbose -V -\#\#\#; do
6686 <  cat >conftest.$ac_ext <<_ACEOF
6687 <      program main
6688 <
6689 <      end
6690 < _ACEOF
6691 <
6692 < # Compile and link our simple test program by passing a flag (argument
6693 < # 1 to this macro) to the Fortran compiler in order to get
6694 < # "verbose" output that we can then parse for the Fortran linker
6695 < # flags.
6696 < ac_save_FFLAGS=$FCFLAGS
6697 < FCFLAGS="$FCFLAGS $ac_verb"
6698 < eval "set x $ac_link"
6699 < shift
6700 < echo "$as_me:$LINENO: $*" >&5
6701 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
6702 < echo "$ac_fc_v_output" >&5
6703 < FCFLAGS=$ac_save_FFLAGS
6704 <
6705 < rm -f conftest*
6706 <
6707 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6708 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6709 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6710 < ac_fc_v_output="`echo $ac_fc_v_output |
6711 <        grep 'LPATH is:' |
6712 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
6713 <
6714 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6715 < #        that detects unbalanced quotes in FLIBS should be implemented
6716 < #        and (ugh) tested at some point.
6717 < case $ac_fc_v_output in
6718 <  # If we are using xlf then replace all the commas with spaces.
6719 <  *xlfentry*)
6720 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6721 <
6722 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6723 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6724 <  *mGLOB_options_string*)
6725 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6726 <
6727 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6728 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6729 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6730 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6731 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6732 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6733 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6734 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6735 <
6736 <  # If we are using Cray Fortran then delete quotes.
6737 <  *cft90*)
6738 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6739 < esac
6740 <
6741 <
6742 <  # look for -l* and *.a constructs in the output
6743 <  for ac_arg in $ac_fc_v_output; do
6744 <     case $ac_arg in
6745 <        [\\/]*.a | ?:[\\/]*.a | -[lLRu]*)
6746 <          ac_cv_prog_fc_v=$ac_verb
6747 <          break 2 ;;
6748 <     esac
6749 <  done
6750 < done
6751 < if test -z "$ac_cv_prog_fc_v"; then
6752 <   { echo "$as_me:$LINENO: WARNING: cannot determine how to obtain linking information from $FC" >&5
6753 < echo "$as_me: WARNING: cannot determine how to obtain linking information from $FC" >&2;}
6754 < fi
6755 < else
6756 <  echo "$as_me: failed program was:" >&5
6757 < sed 's/^/| /' conftest.$ac_ext >&5
6758 <
6759 <        { echo "$as_me:$LINENO: WARNING: compilation failed" >&5
6760 < echo "$as_me: WARNING: compilation failed" >&2;}
6761 < fi
6762 <
6763 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6764 <
6765 < fi
6766 < { echo "$as_me:$LINENO: result: $ac_cv_prog_fc_v" >&5
6767 < echo "${ECHO_T}$ac_cv_prog_fc_v" >&6; }
6768 < { echo "$as_me:$LINENO: checking for Fortran libraries of $FC" >&5
6769 < echo $ECHO_N "checking for Fortran libraries of $FC... $ECHO_C" >&6; }
6770 < if test "${ac_cv_fc_libs+set}" = set; then
6771 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6772 < else
6773 <  if test "x$FCLIBS" != "x"; then
6774 <  ac_cv_fc_libs="$FCLIBS" # Let the user override the test.
6775 < else
6776 <
6777 < cat >conftest.$ac_ext <<_ACEOF
6778 <      program main
6779 <
6780 <      end
6781 < _ACEOF
6782 <
6783 < # Compile and link our simple test program by passing a flag (argument
6784 < # 1 to this macro) to the Fortran compiler in order to get
6785 < # "verbose" output that we can then parse for the Fortran linker
6786 < # flags.
6787 < ac_save_FFLAGS=$FCFLAGS
6788 < FCFLAGS="$FCFLAGS $ac_cv_prog_fc_v"
6789 < eval "set x $ac_link"
6790 < shift
6791 < echo "$as_me:$LINENO: $*" >&5
6792 < ac_fc_v_output=`eval $ac_link 5>&1 2>&1 | grep -v 'Driving:'`
6793 < echo "$ac_fc_v_output" >&5
6794 < FCFLAGS=$ac_save_FFLAGS
6795 <
6796 < rm -f conftest*
6797 <
6798 < # On HP/UX there is a line like: "LPATH is: /foo:/bar:/baz" where
6799 < # /foo, /bar, and /baz are search directories for the Fortran linker.
6800 < # Here, we change these into -L/foo -L/bar -L/baz (and put it first):
6801 < ac_fc_v_output="`echo $ac_fc_v_output |
6802 <        grep 'LPATH is:' |
6803 <        sed 's,.*LPATH is\(: *[^ ]*\).*,\1,;s,: */, -L/,g'` $ac_fc_v_output"
6804 <
6805 < # FIXME: we keep getting bitten by quoted arguments; a more general fix
6806 < #        that detects unbalanced quotes in FLIBS should be implemented
6807 < #        and (ugh) tested at some point.
6808 < case $ac_fc_v_output in
6809 <  # If we are using xlf then replace all the commas with spaces.
6810 <  *xlfentry*)
6811 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/,/ /g'` ;;
6812 <
6813 <  # With Intel ifc, ignore the quoted -mGLOB_options_string stuff (quoted
6814 <  # $LIBS confuse us, and the libraries appear later in the output anyway).
6815 <  *mGLOB_options_string*)
6816 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"-mGLOB[^"]*"/ /g'` ;;
6817 <
6818 <  # Portland Group compiler has singly- or doubly-quoted -cmdline argument
6819 <  # Singly-quoted arguments were reported for versions 5.2-4 and 6.0-4.
6820 <  # Doubly-quoted arguments were reported for "PGF90/x86 Linux/x86 5.0-2".
6821 <  *-cmdline\ * | *-ignore\ * | *-def\ *)
6822 <    ac_fc_v_output=`echo $ac_fc_v_output | sed "\
6823 <        s/-cmdline  *'[^']*'/ /g; s/-cmdline  *\"[^\"]*\"/ /g
6824 <        s/-ignore  *'[^']*'/ /g; s/-ignore  *\"[^\"]*\"/ /g
6825 <        s/-def  *'[^']*'/ /g; s/-def  *\"[^\"]*\"/ /g"` ;;
6826 <
6827 <  # If we are using Cray Fortran then delete quotes.
6828 <  *cft90*)
6829 <    ac_fc_v_output=`echo $ac_fc_v_output | sed 's/"//g'` ;;
6830 < esac
6831 <
6832 <
6833 <
6834 < ac_cv_fc_libs=
6835 <
6836 < # Save positional arguments (if any)
6837 < ac_save_positional="$@"
6838 <
6839 < set X $ac_fc_v_output
6840 < while test $# != 1; do
6841 <  shift
6842 <  ac_arg=$1
6843 <  case $ac_arg in
6844 <        [\\/]*.a | ?:[\\/]*.a)
6845 <            ac_exists=false
6846 <  for ac_i in $ac_cv_fc_libs; do
6847 <    if test x"$ac_arg" = x"$ac_i"; then
6848 <      ac_exists=true
6849 <      break
6850 <    fi
6851 <  done
6852 <
6853 <  if test x"$ac_exists" = xtrue; then
6854 <  :
6855 < else
6856 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6857 < fi
6858 <
6859 <          ;;
6860 <        -bI:*)
6861 <            ac_exists=false
6862 <  for ac_i in $ac_cv_fc_libs; do
6863 <    if test x"$ac_arg" = x"$ac_i"; then
6864 <      ac_exists=true
6865 <      break
6866 <    fi
6867 <  done
6868 <
6869 <  if test x"$ac_exists" = xtrue; then
6870 <  :
6871 < else
6872 <  if test "$ac_compiler_gnu" = yes; then
6873 <  for ac_link_opt in $ac_arg; do
6874 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6875 <  done
6876 < else
6877 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6878 < fi
6879 < fi
6880 <
6881 <          ;;
6882 <          # Ignore these flags.
6883 <        -lang* | -lcrt*.o | -lc | -lgcc* | -lSystem | -libmil | -LANG:=* | -LIST:* | -LNO:*)
6884 <          ;;
6885 <        -lkernel32)
6886 <          test x"$CYGWIN" != xyes && ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6887 <          ;;
6888 <        -[LRuYz])
6889 <          # These flags, when seen by themselves, take an argument.
6890 <          # We remove the space between option and argument and re-iterate
6891 <          # unless we find an empty arg or a new option (starting with -)
6892 <          case $2 in
6893 <             "" | -*);;
6894 <             *)
6895 <                ac_arg="$ac_arg$2"
6896 <                shift; shift
6897 <                set X $ac_arg "$@"
6898 <                ;;
6899 <          esac
6900 <          ;;
6901 <        -YP,*)
6902 <          for ac_j in `echo $ac_arg | sed -e 's/-YP,/-L/;s/:/ -L/g'`; do
6903 <              ac_exists=false
6904 <  for ac_i in $ac_cv_fc_libs; do
6905 <    if test x"$ac_j" = x"$ac_i"; then
6906 <      ac_exists=true
6907 <      break
6908 <    fi
6909 <  done
6910 <
6911 <  if test x"$ac_exists" = xtrue; then
6912 <  :
6913 < else
6914 <  ac_arg="$ac_arg $ac_j"
6915 <                               ac_cv_fc_libs="$ac_cv_fc_libs $ac_j"
6916 < fi
6917 <
6918 <          done
6919 <          ;;
6920 <        -[lLR]*)
6921 <            ac_exists=false
6922 <  for ac_i in $ac_cv_fc_libs; do
6923 <    if test x"$ac_arg" = x"$ac_i"; then
6924 <      ac_exists=true
6925 <      break
6926 <    fi
6927 <  done
6928 <
6929 <  if test x"$ac_exists" = xtrue; then
6930 <  :
6931 < else
6932 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6933 < fi
6934 <
6935 <          ;;
6936 <        -zallextract*| -zdefaultextract)
6937 <          ac_cv_fc_libs="$ac_cv_fc_libs $ac_arg"
6938 <          ;;
6939 <          # Ignore everything else.
6940 <  esac
6941 < done
6942 < # restore positional arguments
6943 < set X $ac_save_positional; shift
6944 <
6945 < # We only consider "LD_RUN_PATH" on Solaris systems.  If this is seen,
6946 < # then we insist that the "run path" must be an absolute path (i.e. it
6947 < # must begin with a "/").
6948 < case `(uname -sr) 2>/dev/null` in
6949 <   "SunOS 5"*)
6950 <      ac_ld_run_path=`echo $ac_fc_v_output |
6951 <                        sed -n 's,^.*LD_RUN_PATH *= *\(/[^ ]*\).*$,-R\1,p'`
6952 <      test "x$ac_ld_run_path" != x &&
6953 <        if test "$ac_compiler_gnu" = yes; then
6954 <  for ac_link_opt in $ac_ld_run_path; do
6955 <    ac_cv_fc_libs="$ac_cv_fc_libs -Xlinker $ac_link_opt"
6956 <  done
6957 < else
6958 <  ac_cv_fc_libs="$ac_cv_fc_libs $ac_ld_run_path"
6959 < fi
6960 <      ;;
6961 < esac
6962 < fi # test "x$[]_AC_LANG_PREFIX[]LIBS" = "x"
6963 <
6964 < fi
6965 < { echo "$as_me:$LINENO: result: $ac_cv_fc_libs" >&5
6966 < echo "${ECHO_T}$ac_cv_fc_libs" >&6; }
6967 < FCLIBS="$ac_cv_fc_libs"
6968 <
6969 <
6970 < ac_ext=${ac_fc_srcext-f}
6971 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
6972 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
6973 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
6974 <
6975 <
6976 <
6977 < { echo "$as_me:$LINENO: checking for module suffix" >&5
6978 < echo $ECHO_N "checking for module suffix... $ECHO_C" >&6; }
6979 < rm -f conftest*
6980 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
6981 < rm -f work*
6982 < cat >conftest.$ac_ext <<EOF
6983 <        module conftest
6984 <        integer n
6985 <        parameter (n=1)
6986 <        end module conftest
6987 < EOF
6988 < # SGI and absoft compilers generates module name in upper case!
6989 < testname="conftest"
6990 < modcase="lower"
6991 < if (eval $ac_compile) 2>/dev/null ; then
6992 <    MOD=`ls conftest* | grep -v conftest.$ac_ext | grep -v conftest.o`
6993 <    MOD=`echo "$MOD" | sed -e 's/conftest\.//g'`
6994 <    if test -z "$MOD" ; then
6995 <        MOD=`ls CONFTEST* 2>/dev/null \
6996 <                | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
6997 <        MOD=`echo "$MOD" | sed -e 's/CONFTEST\.//g'`
6998 <        if test -n "$MOD" ; then
6999 <            testname="CONFTEST"
7000 <            modcase="upper"
7001 <        fi
7002 <    fi
7003 <    if test -z "$MOD" ; then
7004 <        { echo "$as_me:$LINENO: result: unknown" >&5
7005 < echo "${ECHO_T}unknown" >&6; }
7006 <        # Use mod if we can't figure it out
7007 <        MOD="mod"
7008 <    else
7009 <        { echo "$as_me:$LINENO: result: $MOD" >&5
7010 < echo "${ECHO_T}$MOD" >&6; }
7011 <    fi
7012 <    if test -s work.pcl ; then
7013 <        { echo "$as_me:$LINENO: WARNING: Compiler generates auxillery files!" >&5
7014 < echo "$as_me: WARNING: Compiler generates auxillery files!" >&2;}
7015 <    fi
7016 < else
7017 <    { echo "$as_me:$LINENO: result: unknown" >&5
7018 < echo "${ECHO_T}unknown" >&6; }
7019 < fi
7020 <
7021 <
7022 <
7023 <
7024 <
7025 < # Check for module include path (some use -I, some (Solaris) use -M, some
7026 < # (absoft) use -p).
7027 < # Intel compilers use a wierd system: -cl,filename.pcl .  If no file is
7028 < # specified, work.pcl and work.pc are created.  However, if you specify
7029 < # a file, it must contain a the name of a file ending in .pc .  Ugh!
7030 < # Use the module made above
7031 < { echo "$as_me:$LINENO: checking for module directory path flag" >&5
7032 < echo $ECHO_N "checking for module directory path flag... $ECHO_C" >&6; }
7033 < rm -f conftest*
7034 < # Intel ifc compiler generates files by the name of work.pc and work.pcl (!)
7035 < rm -f work*
7036 < cat >conftest.$ac_ext <<EOF
7037 <        module conftest
7038 <        integer n
7039 <        parameter (n=1)
7040 <        end module conftest
7041 < EOF
7042 < # SGI and absoft compilers generates module name in upper case!
7043 < testname="conftest"
7044 < if (eval $ac_compile) 2>/dev/null ; then
7045 <   mod=`ls CONFTEST* 2>/dev/null | grep -v CONFTEST.$ac_ext | grep -v CONFTEST.o`
7046 <   mod=`echo "$mod" | sed -e 's/CONFTEST\.//g'`
7047 <   if test -n "$mod" ; then
7048 <      testname="CONFTEST"
7049 <   fi
7050 <   madedir=0
7051 <   if test ! -d conf ; then mkdir conf ; madedir=1; fi
7052 <   cp $testname.$MOD conf
7053 <   rm -f conftest* CONFTEST*
7054 <   cat >conftest1.$ac_ext <<EOF
7055 <        program main
7056 <        use conftest
7057 <        print *, n
7058 <        end
7059 < EOF
7060 <   F90_WORK_FILES_ARG=""
7061 <   F90MODINCSPEC=""
7062 <   if $FC -c -Iconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext > conftest.out 2>&1 ; then
7063 <       MODDIRFLAG="-I"
7064 <       F90MODINCSPEC="-I<dir>"
7065 <       { echo "$as_me:$LINENO: result: -I" >&5
7066 < echo "${ECHO_T}-I" >&6; }
7067 <   elif $FC -c -Mconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
7068 <       MODDIRFLAG="-M"
7069 <       F90MODINCSPEC="-M<dir>"
7070 <       { echo "$as_me:$LINENO: result: -M" >&5
7071 < echo "${ECHO_T}-M" >&6; }
7072 <   elif $FC -c -pconf $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >> conftest.out 2>&1 ; then
7073 <       MODDIRFLAG="-p"
7074 <       F90MODINCSPEC="-p<dir>"
7075 <       { echo "$as_me:$LINENO: result: -p" >&5
7076 < echo "${ECHO_T}-p" >&6; }
7077 <   elif test -s work.pc ; then
7078 <        cp work.pc conf/mpimod.pc
7079 <        echo "mpimod.pc" > conf/mpimod.pcl
7080 <        echo "`pwd`/conf/mpimod.pc" >> conf/mpimod.pcl
7081 <        if $FC -c -cl,conf/mpimod.pcl $FCFLAGS $FCFLAGS_SRCEXT conftest1.$ac_ext >>conftest.out 2>&1 ; then
7082 <            MODDIRFLAG='-cl,mpimod.pcl'
7083 <            { echo "$as_me:$LINENO: result: -cl,filename where filename contains a list of files and directories" >&5
7084 < echo "${ECHO_T}-cl,filename where filename contains a list of files and directories" >&6; }
7085 <            F90_WORK_FILES_ARG="-cl,mpimod.pcl"
7086 <            F90MODINCSPEC="-cl,<dir>/<file>mod.pcl"
7087 <
7088 <        else
7089 <            # The version of the Intel compiler that I have refuses to let
7090 <            # you put the "work catalog" list anywhere but the current
7091 <            # directory. For example, you cannot in
7092 <         :
7093 <        fi
7094 <   fi
7095 <   if test -z "MODDIRFLAG" ; then
7096 <       { echo "$as_me:$LINENO: result: unknown" >&5
7097 < echo "${ECHO_T}unknown" >&6; }
7098 <   fi
7099 <
7100 <
7101 <   rm -f conftest* conf/conftest* conf/CONFTEST* CONFTEST* conf/mpimod*
7102 <   if test $madedir = 1 ; then rmdir conf ; fi
7103 < fi
7104 <
7105 <
7106 < { echo "$as_me:$LINENO: checking for Fortran 90 module file names" >&5
7107 < echo $ECHO_N "checking for Fortran 90 module file names... $ECHO_C" >&6; }
7108 < if test "${ac_cv_f90_module_names+set}" = set; then
7109 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7110 < else
7111 <  ac_ext=${ac_fc_srcext-f}
7112 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7113 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7114 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7115 <
7116 < # carry out the test in a new directory, so that we don't miss anything
7117 < mkdir conftest
7118 < cd conftest
7119 < cat >conftest.$ac_ext <<_ACEOF
7120 < MODULE Bar
7121 < END MODULE Bar
7122 < _ACEOF
7123 < rm -f conftest.$ac_objext
7124 < if { (ac_try="$ac_compile"
7125 < case "(($ac_try" in
7126 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7127 <  *) ac_try_echo=$ac_try;;
7128 < esac
7129 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7130 <  (eval "$ac_compile") 2>conftest.er1
7131 <  ac_status=$?
7132 <  grep -v '^ *+' conftest.er1 >conftest.err
7133 <  rm -f conftest.er1
7134 <  cat conftest.err >&5
7135 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7136 <  (exit $ac_status); } && {
7137 <         test -z "$ac_fc_werror_flag" ||
7138 <         test ! -s conftest.err
7139 <       } && test -s conftest.$ac_objext; then
7140 <  ac_cv_f90_module_names=
7141 < ac_file_list=*
7142 < for ac_file in $ac_file_list; do
7143 <   case $ac_file in
7144 <      # don't care for original source and object files
7145 <      conftest.$ac_ext | conftest.$ac_objext | conftest.err )
7146 <          :
7147 <          ;;
7148 <      # look for new files derived from the file name
7149 <      *conftest*)
7150 <          ac_pat=`echo $ac_file | sed s/conftest/%FILE%/`
7151 <            ac_exists=false
7152 <  for ac_i in $ac_cv_f90_module_names; do
7153 <    if test x"$ac_pat" = x"$ac_i"; then
7154 <      ac_exists=true
7155 <      break
7156 <    fi
7157 <  done
7158 <
7159 <  if test x"$ac_exists" = xtrue; then
7160 <  :
7161 < else
7162 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7163 < fi
7164 <
7165 <          ;;
7166 <      # look for new files derived from the module name,
7167 <      # with different case translation schemes
7168 <      *Bar*)
7169 <          ac_pat=`echo $ac_file | sed s/Bar/%Module%/`
7170 <            ac_exists=false
7171 <  for ac_i in $ac_cv_f90_module_names; do
7172 <    if test x"$ac_pat" = x"$ac_i"; then
7173 <      ac_exists=true
7174 <      break
7175 <    fi
7176 <  done
7177 <
7178 <  if test x"$ac_exists" = xtrue; then
7179 <  :
7180 < else
7181 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7182 < fi
7183 <
7184 <          ;;
7185 <      *bar*)
7186 <          ac_pat=`echo $ac_file | sed s/bar/%module%/`
7187 <            ac_exists=false
7188 <  for ac_i in $ac_cv_f90_module_names; do
7189 <    if test x"$ac_pat" = x"$ac_i"; then
7190 <      ac_exists=true
7191 <      break
7192 <    fi
7193 <  done
7194 <
7195 <  if test x"$ac_exists" = xtrue; then
7196 <  :
7197 < else
7198 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7199 < fi
7200 <
7201 <          ;;
7202 <      *BAR*)
7203 <          ac_pat=`echo $ac_file | sed s/BAR/%MODULE%/`
7204 <            ac_exists=false
7205 <  for ac_i in $ac_cv_f90_module_names; do
7206 <    if test x"$ac_pat" = x"$ac_i"; then
7207 <      ac_exists=true
7208 <      break
7209 <    fi
7210 <  done
7211 <
7212 <  if test x"$ac_exists" = xtrue; then
7213 <  :
7214 < else
7215 <  ac_cv_f90_module_names="$ac_cv_f90_module_names $ac_pat"
7216 < fi
7217 <
7218 <          ;;
7219 <       # Other files - we have no idea how they are generated
7220 <       *)
7221 <          { echo "$as_me:$LINENO: WARNING: Bogus file found: $ac_file" >&5
7222 < echo "$as_me: WARNING: Bogus file found: $ac_file" >&2;}
7223 <          ;;
7224 <   esac
7225 < done
7226 < if test "x$ac_cv_f90_module_names" = "x"; then
7227 <  { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
7228 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
7229 < fi
7230 <
7231 < else
7232 <  echo "$as_me: failed program was:" >&5
7233 < sed 's/^/| /' conftest.$ac_ext >&5
7234 <
7235 <        ac_cv_f90_module_names=
7236 < { echo "$as_me:$LINENO: WARNING: Couldn't determine module file names" >&5
7237 < echo "$as_me: WARNING: Couldn't determine module file names" >&2;}
7238 < fi
7239 <
7240 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7241 < cd ..
7242 < # cleanup
7243 < rm -rf conftest
7244 < ac_ext=${ac_fc_srcext-f}
7245 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
7246 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
7247 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
7248 <
7249 < fi
7250 < { echo "$as_me:$LINENO: result: $ac_cv_f90_module_names" >&5
7251 < echo "${ECHO_T}$ac_cv_f90_module_names" >&6; } # AC_CACHE_CHECK
7252 <
7253 < # We now generate a shell script that will help us to figure out the correct
7254 < # module file names, using the value of ac_cv_f90_module_names
7255 <
7256 < echo "Generating shell script modnam"
7257 <
7258 < cat > scripts/modnam << EOF
7259 < #! /bin/sh
7260 < # This script is auto-generated by configure
7261 < #
7262 < usage="\\
7263 < Usage: \$0 [FILES]
7264 <
7265 < [FILES] are Fortran 90 source files.
7266 < The output is a list of module file names that the Fortran 90 compiler
7267 < generates when compiling [FILES]."
7268 <
7269 < list=
7270 < empty=
7271 <
7272 < if test \$# -eq 0; then
7273 <   echo "\$usage"; exit 0
7274 < fi
7275 <
7276 < while test \$# != 0; do
7277 <
7278 <  file=\$1
7279 <  shift
7280 <
7281 < # strip suffix
7282 <  base=\`echo \$file | sed 's/[.][^.]*$//'\`
7283 <
7284 <  test ! -f \$file && continue
7285 <
7286 < # Look for module definitions and transform them to upper / lower case
7287 <  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/'\`
7288 <  upper=\`echo \$mods | tr a-z A-Z\`
7289 <  lower=\`echo \$mods | tr A-Z a-z\`
7290 <
7291 < # Here, the patterns for generating module file names were inserted by configure
7292 <  for trans in $ac_cv_f90_module_names; do
7293 <
7294 <    pat=\`echo \$trans | sed 's/.*\(%.*%\).*/\1/'\`
7295 <    var=empty
7296 <    case \$pat in
7297 <       %MODULE%)
7298 <          var=upper ;;
7299 <       %Module%)
7300 <          var=mods ;;
7301 <       %module%)
7302 <          var=lower ;;
7303 <       %FILE%)
7304 <          test -n "\$mods" && var=base ;;
7305 <    esac
7306 <    new=\`eval '(for i in \$'\$var '; do echo \$trans | sed s/\$pat/\$i/; done)'\`
7307 <    list="\$list \$new"
7308 <  done
7309 < done
7310 <
7311 < echo \$list
7312 < # end of configure-generated script
7313 < EOF
7314 < chmod 755 scripts/modnam
7315 <
7316 < pat=`echo $ac_cv_f90_module_names | sed 's/.*\(%.*%\).*/\1/'`
7317 < F90_MODULE_NAMES=empty
7318 < case $pat in
7319 <       %MODULE%)
7320 <          F90_MODULE_NAMES=UPPER ;;
7321 <       %Module%)
7322 <          F90_MODULE_NAMES=Mixed ;;
7323 <       %module%)
7324 <          F90_MODULE_NAMES=lower ;;
7325 <       *)
7326 <          F90_MODULE_NAMES=unknown ;;
7327 < esac
7328 <
7329 < ac_ext=c
7330 < ac_cpp='$CPP $CPPFLAGS'
7331 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7332 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7333 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7334 <
7335 <
7336 < ac_ext=c
7337 < ac_cpp='$CPP $CPPFLAGS'
7338 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7339 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7340 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7341 <
7342 <
7343 <
7344 < { echo "$as_me:$LINENO: checking for asin in -lm" >&5
7345 < echo $ECHO_N "checking for asin in -lm... $ECHO_C" >&6; }
7346 < if test "${ac_cv_lib_m_asin+set}" = set; then
7347 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7348 < else
7349 <  ac_check_lib_save_LIBS=$LIBS
7350 < LIBS="-lm  $LIBS"
7351 < cat >conftest.$ac_ext <<_ACEOF
7352 < /* confdefs.h.  */
7353 < _ACEOF
7354 < cat confdefs.h >>conftest.$ac_ext
7355 < cat >>conftest.$ac_ext <<_ACEOF
7356 < /* end confdefs.h.  */
7357 <
7358 < /* Override any GCC internal prototype to avoid an error.
7359 <   Use char because int might match the return type of a GCC
7360 <   builtin and then its argument prototype would still apply.  */
7361 < #ifdef __cplusplus
7362 < extern "C"
7363 < #endif
7364 < char asin ();
7365 < #ifdef FC_DUMMY_MAIN
7366 < #ifndef FC_DUMMY_MAIN_EQ_F77
7367 < #  ifdef __cplusplus
7368 <     extern "C"
7369 < #  endif
7370 <   int FC_DUMMY_MAIN() { return 1; }
7371 < #endif
7372 < #endif
7373 < int
7374 < main ()
7375 < {
7376 < return asin ();
7377 <  ;
7378 <  return 0;
7379 < }
7380 < _ACEOF
7381 < rm -f conftest.$ac_objext conftest$ac_exeext
7382 < if { (ac_try="$ac_link"
7383 < case "(($ac_try" in
7384 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7385 <  *) ac_try_echo=$ac_try;;
7386 < esac
7387 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7388 <  (eval "$ac_link") 2>conftest.er1
7389 <  ac_status=$?
7390 <  grep -v '^ *+' conftest.er1 >conftest.err
7391 <  rm -f conftest.er1
7392 <  cat conftest.err >&5
7393 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7394 <  (exit $ac_status); } && {
7395 <         test -z "$ac_c_werror_flag" ||
7396 <         test ! -s conftest.err
7397 <       } && test -s conftest$ac_exeext &&
7398 <       $as_test_x conftest$ac_exeext; then
7399 <  ac_cv_lib_m_asin=yes
7400 < else
7401 <  echo "$as_me: failed program was:" >&5
7402 < sed 's/^/| /' conftest.$ac_ext >&5
7403 <
7404 <        ac_cv_lib_m_asin=no
7405 < fi
7406 <
7407 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7408 <      conftest$ac_exeext conftest.$ac_ext
7409 < LIBS=$ac_check_lib_save_LIBS
7410 < fi
7411 < { echo "$as_me:$LINENO: result: $ac_cv_lib_m_asin" >&5
7412 < echo "${ECHO_T}$ac_cv_lib_m_asin" >&6; }
7413 < if test $ac_cv_lib_m_asin = yes; then
7414 <  cat >>confdefs.h <<_ACEOF
7415 < #define HAVE_LIBM 1
7416 < _ACEOF
7417 <
7418 <  LIBS="-lm $LIBS"
7419 <
7420 < else
7421 <  exit
7422 < fi
7423 <
7424 <
7425 < { echo "$as_me:$LINENO: checking for ANSI C header files" >&5
7426 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
7427 < if test "${ac_cv_header_stdc+set}" = set; then
7428 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7429 < else
7430 <  cat >conftest.$ac_ext <<_ACEOF
7431 < /* confdefs.h.  */
7432 < _ACEOF
7433 < cat confdefs.h >>conftest.$ac_ext
7434 < cat >>conftest.$ac_ext <<_ACEOF
7435 < /* end confdefs.h.  */
7436 < #include <stdlib.h>
7437 < #include <stdarg.h>
7438 < #include <string.h>
7439 < #include <float.h>
7440 <
7441 < #ifdef FC_DUMMY_MAIN
7442 < #ifndef FC_DUMMY_MAIN_EQ_F77
7443 < #  ifdef __cplusplus
7444 <     extern "C"
7445 < #  endif
7446 <   int FC_DUMMY_MAIN() { return 1; }
7447 < #endif
7448 < #endif
7449 < int
7450 < main ()
7451 < {
7452 <
7453 <  ;
7454 <  return 0;
7455 < }
7456 < _ACEOF
7457 < rm -f conftest.$ac_objext
7458 < if { (ac_try="$ac_compile"
7459 < case "(($ac_try" in
7460 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7461 <  *) ac_try_echo=$ac_try;;
7462 < esac
7463 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7464 <  (eval "$ac_compile") 2>conftest.er1
7465 <  ac_status=$?
7466 <  grep -v '^ *+' conftest.er1 >conftest.err
7467 <  rm -f conftest.er1
7468 <  cat conftest.err >&5
7469 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7470 <  (exit $ac_status); } && {
7471 <         test -z "$ac_c_werror_flag" ||
7472 <         test ! -s conftest.err
7473 <       } && test -s conftest.$ac_objext; then
7474 <  ac_cv_header_stdc=yes
7475 < else
7476 <  echo "$as_me: failed program was:" >&5
7477 < sed 's/^/| /' conftest.$ac_ext >&5
7478 <
7479 <        ac_cv_header_stdc=no
7480 < fi
7481 <
7482 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7483 <
7484 < if test $ac_cv_header_stdc = yes; then
7485 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
7486 <  cat >conftest.$ac_ext <<_ACEOF
7487 < /* confdefs.h.  */
7488 < _ACEOF
7489 < cat confdefs.h >>conftest.$ac_ext
7490 < cat >>conftest.$ac_ext <<_ACEOF
7491 < /* end confdefs.h.  */
7492 < #include <string.h>
7493 <
7494 < _ACEOF
7495 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7496 <  $EGREP "memchr" >/dev/null 2>&1; then
7497 <  :
7498 < else
7499 <  ac_cv_header_stdc=no
7500 < fi
7501 < rm -f conftest*
7502 <
7503 < fi
7504 <
7505 < if test $ac_cv_header_stdc = yes; then
7506 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
7507 <  cat >conftest.$ac_ext <<_ACEOF
7508 < /* confdefs.h.  */
7509 < _ACEOF
7510 < cat confdefs.h >>conftest.$ac_ext
7511 < cat >>conftest.$ac_ext <<_ACEOF
7512 < /* end confdefs.h.  */
7513 < #include <stdlib.h>
7514 <
7515 < _ACEOF
7516 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
7517 <  $EGREP "free" >/dev/null 2>&1; then
7518 <  :
7519 < else
7520 <  ac_cv_header_stdc=no
7521 < fi
7522 < rm -f conftest*
7523 <
7524 < fi
7525 <
7526 < if test $ac_cv_header_stdc = yes; then
7527 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
7528 <  if test "$cross_compiling" = yes; then
7529 <  :
7530 < else
7531 <  cat >conftest.$ac_ext <<_ACEOF
7532 < /* confdefs.h.  */
7533 < _ACEOF
7534 < cat confdefs.h >>conftest.$ac_ext
7535 < cat >>conftest.$ac_ext <<_ACEOF
7536 < /* end confdefs.h.  */
7537 < #include <ctype.h>
7538 < #include <stdlib.h>
7539 < #if ((' ' & 0x0FF) == 0x020)
7540 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
7541 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
7542 < #else
7543 < # define ISLOWER(c) \
7544 <                   (('a' <= (c) && (c) <= 'i') \
7545 <                     || ('j' <= (c) && (c) <= 'r') \
7546 <                     || ('s' <= (c) && (c) <= 'z'))
7547 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
7548 < #endif
7549 <
7550 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
7551 < int
7552 < main ()
7553 < {
7554 <  int i;
7555 <  for (i = 0; i < 256; i++)
7556 <    if (XOR (islower (i), ISLOWER (i))
7557 <        || toupper (i) != TOUPPER (i))
7558 <      return 2;
7559 <  return 0;
7560 < }
7561 < _ACEOF
7562 < rm -f conftest$ac_exeext
7563 < if { (ac_try="$ac_link"
7564 < case "(($ac_try" in
7565 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7566 <  *) ac_try_echo=$ac_try;;
7567 < esac
7568 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7569 <  (eval "$ac_link") 2>&5
7570 <  ac_status=$?
7571 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7572 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
7573 <  { (case "(($ac_try" in
7574 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7575 <  *) ac_try_echo=$ac_try;;
7576 < esac
7577 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7578 <  (eval "$ac_try") 2>&5
7579 <  ac_status=$?
7580 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7581 <  (exit $ac_status); }; }; then
7582 <  :
7583 < else
7584 <  echo "$as_me: program exited with status $ac_status" >&5
7585 < echo "$as_me: failed program was:" >&5
7586 < sed 's/^/| /' conftest.$ac_ext >&5
7587 <
7588 < ( exit $ac_status )
7589 < ac_cv_header_stdc=no
7590 < fi
7591 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
7592 < fi
7593 <
7594 <
7595 < fi
7596 < fi
7597 < { echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
7598 < echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
7599 < if test $ac_cv_header_stdc = yes; then
7600 <
7601 < cat >>confdefs.h <<\_ACEOF
7602 < #define STDC_HEADERS 1
7603 < _ACEOF
7604 <
7605 < fi
7606 <
7607 < # On IRIX 5.3, sys/types and inttypes.h are conflicting.
7608 <
7609 <
7610 <
7611 <
7612 <
7613 <
7614 <
7615 <
7616 <
7617 < for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
7618 <                  inttypes.h stdint.h unistd.h
7619 < do
7620 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
7621 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
7622 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
7623 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
7624 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7625 < else
7626 <  cat >conftest.$ac_ext <<_ACEOF
7627 < /* confdefs.h.  */
7628 < _ACEOF
7629 < cat confdefs.h >>conftest.$ac_ext
7630 < cat >>conftest.$ac_ext <<_ACEOF
7631 < /* end confdefs.h.  */
7632 < $ac_includes_default
7633 <
7634 < #include <$ac_header>
7635 < _ACEOF
7636 < rm -f conftest.$ac_objext
7637 < if { (ac_try="$ac_compile"
7638 < case "(($ac_try" in
7639 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7640 <  *) ac_try_echo=$ac_try;;
7641 < esac
7642 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7643 <  (eval "$ac_compile") 2>conftest.er1
7644 <  ac_status=$?
7645 <  grep -v '^ *+' conftest.er1 >conftest.err
7646 <  rm -f conftest.er1
7647 <  cat conftest.err >&5
7648 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7649 <  (exit $ac_status); } && {
7650 <         test -z "$ac_c_werror_flag" ||
7651 <         test ! -s conftest.err
7652 <       } && test -s conftest.$ac_objext; then
7653 <  eval "$as_ac_Header=yes"
7654 < else
7655 <  echo "$as_me: failed program was:" >&5
7656 < sed 's/^/| /' conftest.$ac_ext >&5
7657 <
7658 <        eval "$as_ac_Header=no"
7659 < fi
7660 <
7661 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7662 < fi
7663 < ac_res=`eval echo '${'$as_ac_Header'}'`
7664 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
7665 < echo "${ECHO_T}$ac_res" >&6; }
7666 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
7667 <  cat >>confdefs.h <<_ACEOF
7668 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
7669 < _ACEOF
7670 <
7671 < fi
7672 <
7673 < done
7674 <
7675 <
7676 < #
7677 < # Handle user hints
7678 < #
7679 <
7680 < # Check whether --with-zlib was given.
7681 < if test "${with_zlib+set}" = set; then
7682 <  withval=$with_zlib; zlib_dir="$withval"
7683 < else
7684 <                zlib_dir="not_set"
7685 < fi
7686 <
7687 < if test "$zlib_dir" != "no"; then
7688 <
7689 < if test "$zlib_dir" != "not_set" ; then
7690 <  if test -d "$zlib_dir"
7691 <  then
7692 <    ZLIB_HOME="$zlib_dir"
7693 <  else
7694 <    { echo "$as_me:$LINENO: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&5
7695 < echo "$as_me: WARNING: Sorry, $zlib_dir does not exist, checking usual places" >&2;}
7696 <        ZLIB_HOME=/usr/local
7697 <        if test ! -f "${ZLIB_HOME}/include/zlib.h"
7698 <        then
7699 <                ZLIB_HOME=/usr
7700 <        fi
7701 <  fi
7702 < fi
7703 < #
7704 < # Locate zlib, if wanted
7705 < #
7706 < if test -n "${ZLIB_HOME}"
7707 < then
7708 <        ZLIB_OLD_LDFLAGS=$LDFLAGS
7709 <        ZLIB_OLD_CFLAGS=$CFLAGS
7710 <        LDFLAGS="$LDFLAGS -L${ZLIB_HOME}/lib"
7711 <        CFLAGS="$CFLAGS -I${ZLIB_HOME}/include"
7712 <
7713 <        ac_ext=c
7714 < ac_cpp='$CPP $CPPFLAGS'
7715 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7716 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7717 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7718 <
7719 <        { echo "$as_me:$LINENO: checking for inflateEnd in -lz" >&5
7720 < echo $ECHO_N "checking for inflateEnd in -lz... $ECHO_C" >&6; }
7721 < if test "${ac_cv_lib_z_inflateEnd+set}" = set; then
7722 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7723 < else
7724 <  ac_check_lib_save_LIBS=$LIBS
7725 < LIBS="-lz  $LIBS"
7726 < cat >conftest.$ac_ext <<_ACEOF
7727 < /* confdefs.h.  */
7728 < _ACEOF
7729 < cat confdefs.h >>conftest.$ac_ext
7730 < cat >>conftest.$ac_ext <<_ACEOF
7731 < /* end confdefs.h.  */
7732 <
7733 < /* Override any GCC internal prototype to avoid an error.
7734 <   Use char because int might match the return type of a GCC
7735 <   builtin and then its argument prototype would still apply.  */
7736 < #ifdef __cplusplus
7737 < extern "C"
7738 < #endif
7739 < char inflateEnd ();
7740 < #ifdef FC_DUMMY_MAIN
7741 < #ifndef FC_DUMMY_MAIN_EQ_F77
7742 < #  ifdef __cplusplus
7743 <     extern "C"
7744 < #  endif
7745 <   int FC_DUMMY_MAIN() { return 1; }
7746 < #endif
7747 < #endif
7748 < int
7749 < main ()
7750 < {
7751 < return inflateEnd ();
7752 <  ;
7753 <  return 0;
7754 < }
7755 < _ACEOF
7756 < rm -f conftest.$ac_objext conftest$ac_exeext
7757 < if { (ac_try="$ac_link"
7758 < case "(($ac_try" in
7759 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7760 <  *) ac_try_echo=$ac_try;;
7761 < esac
7762 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7763 <  (eval "$ac_link") 2>conftest.er1
7764 <  ac_status=$?
7765 <  grep -v '^ *+' conftest.er1 >conftest.err
7766 <  rm -f conftest.er1
7767 <  cat conftest.err >&5
7768 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7769 <  (exit $ac_status); } && {
7770 <         test -z "$ac_c_werror_flag" ||
7771 <         test ! -s conftest.err
7772 <       } && test -s conftest$ac_exeext &&
7773 <       $as_test_x conftest$ac_exeext; then
7774 <  ac_cv_lib_z_inflateEnd=yes
7775 < else
7776 <  echo "$as_me: failed program was:" >&5
7777 < sed 's/^/| /' conftest.$ac_ext >&5
7778 <
7779 <        ac_cv_lib_z_inflateEnd=no
7780 < fi
7781 <
7782 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
7783 <      conftest$ac_exeext conftest.$ac_ext
7784 < LIBS=$ac_check_lib_save_LIBS
7785 < fi
7786 < { echo "$as_me:$LINENO: result: $ac_cv_lib_z_inflateEnd" >&5
7787 < echo "${ECHO_T}$ac_cv_lib_z_inflateEnd" >&6; }
7788 < if test $ac_cv_lib_z_inflateEnd = yes; then
7789 <  zlib_cv_libz=yes
7790 < else
7791 <  zlib_cv_libz=no
7792 < fi
7793 <
7794 <        if test "${ac_cv_header_zlib_h+set}" = set; then
7795 <  { echo "$as_me:$LINENO: checking for zlib.h" >&5
7796 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6; }
7797 < if test "${ac_cv_header_zlib_h+set}" = set; then
7798 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7799 < fi
7800 < { echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
7801 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6; }
7802 < else
7803 <  # Is the header compilable?
7804 < { echo "$as_me:$LINENO: checking zlib.h usability" >&5
7805 < echo $ECHO_N "checking zlib.h usability... $ECHO_C" >&6; }
7806 < cat >conftest.$ac_ext <<_ACEOF
7807 < /* confdefs.h.  */
7808 < _ACEOF
7809 < cat confdefs.h >>conftest.$ac_ext
7810 < cat >>conftest.$ac_ext <<_ACEOF
7811 < /* end confdefs.h.  */
7812 < $ac_includes_default
7813 < #include <zlib.h>
7814 < _ACEOF
7815 < rm -f conftest.$ac_objext
7816 < if { (ac_try="$ac_compile"
7817 < case "(($ac_try" in
7818 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7819 <  *) ac_try_echo=$ac_try;;
7820 < esac
7821 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7822 <  (eval "$ac_compile") 2>conftest.er1
7823 <  ac_status=$?
7824 <  grep -v '^ *+' conftest.er1 >conftest.err
7825 <  rm -f conftest.er1
7826 <  cat conftest.err >&5
7827 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7828 <  (exit $ac_status); } && {
7829 <         test -z "$ac_c_werror_flag" ||
7830 <         test ! -s conftest.err
7831 <       } && test -s conftest.$ac_objext; then
7832 <  ac_header_compiler=yes
7833 < else
7834 <  echo "$as_me: failed program was:" >&5
7835 < sed 's/^/| /' conftest.$ac_ext >&5
7836 <
7837 <        ac_header_compiler=no
7838 < fi
7839 <
7840 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
7841 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
7842 < echo "${ECHO_T}$ac_header_compiler" >&6; }
7843 <
7844 < # Is the header present?
7845 < { echo "$as_me:$LINENO: checking zlib.h presence" >&5
7846 < echo $ECHO_N "checking zlib.h presence... $ECHO_C" >&6; }
7847 < cat >conftest.$ac_ext <<_ACEOF
7848 < /* confdefs.h.  */
7849 < _ACEOF
7850 < cat confdefs.h >>conftest.$ac_ext
7851 < cat >>conftest.$ac_ext <<_ACEOF
7852 < /* end confdefs.h.  */
7853 < #include <zlib.h>
7854 < _ACEOF
7855 < if { (ac_try="$ac_cpp conftest.$ac_ext"
7856 < case "(($ac_try" in
7857 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
7858 <  *) ac_try_echo=$ac_try;;
7859 < esac
7860 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
7861 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
7862 <  ac_status=$?
7863 <  grep -v '^ *+' conftest.er1 >conftest.err
7864 <  rm -f conftest.er1
7865 <  cat conftest.err >&5
7866 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
7867 <  (exit $ac_status); } >/dev/null && {
7868 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
7869 <         test ! -s conftest.err
7870 <       }; then
7871 <  ac_header_preproc=yes
7872 < else
7873 <  echo "$as_me: failed program was:" >&5
7874 < sed 's/^/| /' conftest.$ac_ext >&5
7875 <
7876 <  ac_header_preproc=no
7877 < fi
7878 <
7879 < rm -f conftest.err conftest.$ac_ext
7880 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
7881 < echo "${ECHO_T}$ac_header_preproc" >&6; }
7882 <
7883 < # So?  What about this header?
7884 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
7885 <  yes:no: )
7886 <    { echo "$as_me:$LINENO: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&5
7887 < echo "$as_me: WARNING: zlib.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
7888 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the compiler's result" >&5
7889 < echo "$as_me: WARNING: zlib.h: proceeding with the compiler's result" >&2;}
7890 <    ac_header_preproc=yes
7891 <    ;;
7892 <  no:yes:* )
7893 <    { echo "$as_me:$LINENO: WARNING: zlib.h: present but cannot be compiled" >&5
7894 < echo "$as_me: WARNING: zlib.h: present but cannot be compiled" >&2;}
7895 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     check for missing prerequisite headers?" >&5
7896 < echo "$as_me: WARNING: zlib.h:     check for missing prerequisite headers?" >&2;}
7897 <    { echo "$as_me:$LINENO: WARNING: zlib.h: see the Autoconf documentation" >&5
7898 < echo "$as_me: WARNING: zlib.h: see the Autoconf documentation" >&2;}
7899 <    { echo "$as_me:$LINENO: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&5
7900 < echo "$as_me: WARNING: zlib.h:     section \"Present But Cannot Be Compiled\"" >&2;}
7901 <    { echo "$as_me:$LINENO: WARNING: zlib.h: proceeding with the preprocessor's result" >&5
7902 < echo "$as_me: WARNING: zlib.h: proceeding with the preprocessor's result" >&2;}
7903 <    { echo "$as_me:$LINENO: WARNING: zlib.h: in the future, the compiler will take precedence" >&5
7904 < echo "$as_me: WARNING: zlib.h: in the future, the compiler will take precedence" >&2;}
7905 <    ( cat <<\_ASBOX
7906 < ## ------------------------------ ##
7907 < ## Report this to gezelter@nd.edu ##
7908 < ## ------------------------------ ##
7909 < _ASBOX
7910 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
7911 <    ;;
7912 < esac
7913 < { echo "$as_me:$LINENO: checking for zlib.h" >&5
7914 < echo $ECHO_N "checking for zlib.h... $ECHO_C" >&6; }
7915 < if test "${ac_cv_header_zlib_h+set}" = set; then
7916 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7917 < else
7918 <  ac_cv_header_zlib_h=$ac_header_preproc
7919 < fi
7920 < { echo "$as_me:$LINENO: result: $ac_cv_header_zlib_h" >&5
7921 < echo "${ECHO_T}$ac_cv_header_zlib_h" >&6; }
7922 <
7923 < fi
7924 < if test $ac_cv_header_zlib_h = yes; then
7925 <  zlib_cv_zlib_h=yes
7926 < else
7927 <  zlib_cv_zlib_h=no
7928 < fi
7929 <
7930 <
7931 <        ac_ext=c
7932 < ac_cpp='$CPP $CPPFLAGS'
7933 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
7934 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
7935 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
7936 <
7937 <
7938 <        if test "$zlib_cv_libz" = "yes" -a "$zlib_cv_zlib_h" = "yes"; then
7939 <
7940 < cat >>confdefs.h <<\_ACEOF
7941 < #define HAVE_ZLIB_H 1
7942 < _ACEOF
7943 <
7944 <
7945 < cat >>confdefs.h <<\_ACEOF
7946 < #define HAVE_LIBZ 1
7947 < _ACEOF
7948 <
7949 <                ZLIB_INC_DIR="${ZLIB_HOME}/include"
7950 <                ZLIB_LIB_DIR="${ZLIB_HOME}/lib"
7951 <                ZLIB="-lz"
7952 <        else
7953 <                { echo "$as_me:$LINENO: checking zlib in ${ZLIB_HOME}" >&5
7954 < echo $ECHO_N "checking zlib in ${ZLIB_HOME}... $ECHO_C" >&6; }
7955 <                ZLIB_INC_DIR=
7956 <                ZLIB_LIB_DIR=
7957 <                ZLIB=
7958 <                LDFLAGS="$ZLIB_OLD_LDFLAGS"
7959 <                CFLAGS="$ZLIB_OLD_CFLAGS"
7960 <                { echo "$as_me:$LINENO: result: failed" >&5
7961 < echo "${ECHO_T}failed" >&6; }
7962 <                echo ""
7963 <                echo "*********************************************************"
7964 <                echo "* WARNING: Could not find a working zlib installation   *"
7965 <                echo "* If you need OOPSE to be able to deal with compressed  *"
7966 <                echo "* trajectory dump files be sure to specify a valid zlib *"
7967 <                echo "* installation with --with-zlib=DIR                     *"
7968 <                echo "*                                                       *"
7969 <                echo "* OOPSE will still work without zlib installed.         *"
7970 <                echo "*********************************************************"
7971 <                echo ""
7972 <        fi
7973 <
7974 <
7975 <
7976 < fi
7977 < fi
7978 <
7979 < #
7980 < # Handle user hints
7981 < #
7982 <
7983 < # Check whether --with-fftw was given.
7984 < if test "${with_fftw+set}" = set; then
7985 <  withval=$with_fftw; fftw_dir="$withval"
7986 < else
7987 <             fftw_dir="not_set"
7988 < fi
7989 <
7990 < if test "$fftw_dir" != "no"; then
7991 <  if test "$fftw_dir" != "not_set" ; then
7992 <    if test -d "$fftw_dir"; then
7993 <      FFTW_HOME="$fftw_dir"
7994 <    else
7995 <      { echo "$as_me:$LINENO: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&5
7996 < echo "$as_me: WARNING: Sorry, $fftw_dir does not exist, checking usual places" >&2;}
7997 <      FFTW_HOME=/usr/local
7998 <      if test ! -f "${FFTW_HOME}/include/fftw3.h" -o -f "${FFTW_HOME}/include/fftw.h" -o  -f "${FFTW_HOME}/include/dfftw.h"; then
7999 <        FFTW_HOME=/usr
8000 <      fi
8001 <    fi
8002 <    #
8003 <    # Locate fftw, if wanted
8004 <    #
8005 <    if test -n "${FFTW_HOME}"; then
8006 <      FFTW_OLD_LDFLAGS=$LDFLAGS
8007 <      FFTW_OLD_CFLAGS=$CFLAGS
8008 <      LDFLAGS="$LDFLAGS -L${FFTW_HOME}/lib"
8009 <      CFLAGS="$CFLAGS -I${FFTW_HOME}/include"
8010 <
8011 <      ac_ext=c
8012 < ac_cpp='$CPP $CPPFLAGS'
8013 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8014 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8015 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8016 <
8017 <      { echo "$as_me:$LINENO: checking for fftw_execute in -lfftw3" >&5
8018 < echo $ECHO_N "checking for fftw_execute in -lfftw3... $ECHO_C" >&6; }
8019 < if test "${ac_cv_lib_fftw3_fftw_execute+set}" = set; then
8020 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8021 < else
8022 <  ac_check_lib_save_LIBS=$LIBS
8023 < LIBS="-lfftw3  $LIBS"
8024 < cat >conftest.$ac_ext <<_ACEOF
8025 < /* confdefs.h.  */
8026 < _ACEOF
8027 < cat confdefs.h >>conftest.$ac_ext
8028 < cat >>conftest.$ac_ext <<_ACEOF
8029 < /* end confdefs.h.  */
8030 <
8031 < /* Override any GCC internal prototype to avoid an error.
8032 <   Use char because int might match the return type of a GCC
8033 <   builtin and then its argument prototype would still apply.  */
8034 < #ifdef __cplusplus
8035 < extern "C"
8036 < #endif
8037 < char fftw_execute ();
8038 < #ifdef FC_DUMMY_MAIN
8039 < #ifndef FC_DUMMY_MAIN_EQ_F77
8040 < #  ifdef __cplusplus
8041 <     extern "C"
8042 < #  endif
8043 <   int FC_DUMMY_MAIN() { return 1; }
8044 < #endif
8045 < #endif
8046 < int
8047 < main ()
8048 < {
8049 < return fftw_execute ();
8050 <  ;
8051 <  return 0;
8052 < }
8053 < _ACEOF
8054 < rm -f conftest.$ac_objext conftest$ac_exeext
8055 < if { (ac_try="$ac_link"
8056 < case "(($ac_try" in
8057 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8058 <  *) ac_try_echo=$ac_try;;
8059 < esac
8060 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8061 <  (eval "$ac_link") 2>conftest.er1
8062 <  ac_status=$?
8063 <  grep -v '^ *+' conftest.er1 >conftest.err
8064 <  rm -f conftest.er1
8065 <  cat conftest.err >&5
8066 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8067 <  (exit $ac_status); } && {
8068 <         test -z "$ac_c_werror_flag" ||
8069 <         test ! -s conftest.err
8070 <       } && test -s conftest$ac_exeext &&
8071 <       $as_test_x conftest$ac_exeext; then
8072 <  ac_cv_lib_fftw3_fftw_execute=yes
8073 < else
8074 <  echo "$as_me: failed program was:" >&5
8075 < sed 's/^/| /' conftest.$ac_ext >&5
8076 <
8077 <        ac_cv_lib_fftw3_fftw_execute=no
8078 < fi
8079 <
8080 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8081 <      conftest$ac_exeext conftest.$ac_ext
8082 < LIBS=$ac_check_lib_save_LIBS
8083 < fi
8084 < { echo "$as_me:$LINENO: result: $ac_cv_lib_fftw3_fftw_execute" >&5
8085 < echo "${ECHO_T}$ac_cv_lib_fftw3_fftw_execute" >&6; }
8086 < if test $ac_cv_lib_fftw3_fftw_execute = yes; then
8087 <  fftw_cv_libfftw3=yes
8088 < else
8089 <  fftw_cv_libfftw3=no
8090 < fi
8091 <
8092 <      if test "${ac_cv_header_fftw3_h+set}" = set; then
8093 <  { echo "$as_me:$LINENO: checking for fftw3.h" >&5
8094 < echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6; }
8095 < if test "${ac_cv_header_fftw3_h+set}" = set; then
8096 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8097 < fi
8098 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8099 < echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6; }
8100 < else
8101 <  # Is the header compilable?
8102 < { echo "$as_me:$LINENO: checking fftw3.h usability" >&5
8103 < echo $ECHO_N "checking fftw3.h usability... $ECHO_C" >&6; }
8104 < cat >conftest.$ac_ext <<_ACEOF
8105 < /* confdefs.h.  */
8106 < _ACEOF
8107 < cat confdefs.h >>conftest.$ac_ext
8108 < cat >>conftest.$ac_ext <<_ACEOF
8109 < /* end confdefs.h.  */
8110 < $ac_includes_default
8111 < #include <fftw3.h>
8112 < _ACEOF
8113 < rm -f conftest.$ac_objext
8114 < if { (ac_try="$ac_compile"
8115 < case "(($ac_try" in
8116 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8117 <  *) ac_try_echo=$ac_try;;
8118 < esac
8119 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8120 <  (eval "$ac_compile") 2>conftest.er1
8121 <  ac_status=$?
8122 <  grep -v '^ *+' conftest.er1 >conftest.err
8123 <  rm -f conftest.er1
8124 <  cat conftest.err >&5
8125 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8126 <  (exit $ac_status); } && {
8127 <         test -z "$ac_c_werror_flag" ||
8128 <         test ! -s conftest.err
8129 <       } && test -s conftest.$ac_objext; then
8130 <  ac_header_compiler=yes
8131 < else
8132 <  echo "$as_me: failed program was:" >&5
8133 < sed 's/^/| /' conftest.$ac_ext >&5
8134 <
8135 <        ac_header_compiler=no
8136 < fi
8137 <
8138 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8139 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8140 < echo "${ECHO_T}$ac_header_compiler" >&6; }
8141 <
8142 < # Is the header present?
8143 < { echo "$as_me:$LINENO: checking fftw3.h presence" >&5
8144 < echo $ECHO_N "checking fftw3.h presence... $ECHO_C" >&6; }
8145 < cat >conftest.$ac_ext <<_ACEOF
8146 < /* confdefs.h.  */
8147 < _ACEOF
8148 < cat confdefs.h >>conftest.$ac_ext
8149 < cat >>conftest.$ac_ext <<_ACEOF
8150 < /* end confdefs.h.  */
8151 < #include <fftw3.h>
8152 < _ACEOF
8153 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8154 < case "(($ac_try" in
8155 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8156 <  *) ac_try_echo=$ac_try;;
8157 < esac
8158 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8159 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8160 <  ac_status=$?
8161 <  grep -v '^ *+' conftest.er1 >conftest.err
8162 <  rm -f conftest.er1
8163 <  cat conftest.err >&5
8164 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8165 <  (exit $ac_status); } >/dev/null && {
8166 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8167 <         test ! -s conftest.err
8168 <       }; then
8169 <  ac_header_preproc=yes
8170 < else
8171 <  echo "$as_me: failed program was:" >&5
8172 < sed 's/^/| /' conftest.$ac_ext >&5
8173 <
8174 <  ac_header_preproc=no
8175 < fi
8176 <
8177 < rm -f conftest.err conftest.$ac_ext
8178 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8179 < echo "${ECHO_T}$ac_header_preproc" >&6; }
8180 <
8181 < # So?  What about this header?
8182 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8183 <  yes:no: )
8184 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&5
8185 < echo "$as_me: WARNING: fftw3.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8186 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the compiler's result" >&5
8187 < echo "$as_me: WARNING: fftw3.h: proceeding with the compiler's result" >&2;}
8188 <    ac_header_preproc=yes
8189 <    ;;
8190 <  no:yes:* )
8191 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: present but cannot be compiled" >&5
8192 < echo "$as_me: WARNING: fftw3.h: present but cannot be compiled" >&2;}
8193 <    { echo "$as_me:$LINENO: WARNING: fftw3.h:     check for missing prerequisite headers?" >&5
8194 < echo "$as_me: WARNING: fftw3.h:     check for missing prerequisite headers?" >&2;}
8195 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: see the Autoconf documentation" >&5
8196 < echo "$as_me: WARNING: fftw3.h: see the Autoconf documentation" >&2;}
8197 <    { echo "$as_me:$LINENO: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&5
8198 < echo "$as_me: WARNING: fftw3.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8199 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: proceeding with the preprocessor's result" >&5
8200 < echo "$as_me: WARNING: fftw3.h: proceeding with the preprocessor's result" >&2;}
8201 <    { echo "$as_me:$LINENO: WARNING: fftw3.h: in the future, the compiler will take precedence" >&5
8202 < echo "$as_me: WARNING: fftw3.h: in the future, the compiler will take precedence" >&2;}
8203 <    ( cat <<\_ASBOX
8204 < ## ------------------------------ ##
8205 < ## Report this to gezelter@nd.edu ##
8206 < ## ------------------------------ ##
8207 < _ASBOX
8208 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8209 <    ;;
8210 < esac
8211 < { echo "$as_me:$LINENO: checking for fftw3.h" >&5
8212 < echo $ECHO_N "checking for fftw3.h... $ECHO_C" >&6; }
8213 < if test "${ac_cv_header_fftw3_h+set}" = set; then
8214 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8215 < else
8216 <  ac_cv_header_fftw3_h=$ac_header_preproc
8217 < fi
8218 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw3_h" >&5
8219 < echo "${ECHO_T}$ac_cv_header_fftw3_h" >&6; }
8220 <
8221 < fi
8222 < if test $ac_cv_header_fftw3_h = yes; then
8223 <  fftw_cv_fftw3_h=yes
8224 < else
8225 <  fftw_cv_fftw3_h=no
8226 < fi
8227 <
8228 <
8229 <      if test "$fftw_cv_libfftw3" = "no" -o "$fftw_cv_fftw3_h" = "no"; then
8230 <        { echo "$as_me:$LINENO: checking for fftwnd_one in -lfftw" >&5
8231 < echo $ECHO_N "checking for fftwnd_one in -lfftw... $ECHO_C" >&6; }
8232 < if test "${ac_cv_lib_fftw_fftwnd_one+set}" = set; then
8233 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8234 < else
8235 <  ac_check_lib_save_LIBS=$LIBS
8236 < LIBS="-lfftw  $LIBS"
8237 < cat >conftest.$ac_ext <<_ACEOF
8238 < /* confdefs.h.  */
8239 < _ACEOF
8240 < cat confdefs.h >>conftest.$ac_ext
8241 < cat >>conftest.$ac_ext <<_ACEOF
8242 < /* end confdefs.h.  */
8243 <
8244 < /* Override any GCC internal prototype to avoid an error.
8245 <   Use char because int might match the return type of a GCC
8246 <   builtin and then its argument prototype would still apply.  */
8247 < #ifdef __cplusplus
8248 < extern "C"
8249 < #endif
8250 < char fftwnd_one ();
8251 < #ifdef FC_DUMMY_MAIN
8252 < #ifndef FC_DUMMY_MAIN_EQ_F77
8253 < #  ifdef __cplusplus
8254 <     extern "C"
8255 < #  endif
8256 <   int FC_DUMMY_MAIN() { return 1; }
8257 < #endif
8258 < #endif
8259 < int
8260 < main ()
8261 < {
8262 < return fftwnd_one ();
8263 <  ;
8264 <  return 0;
8265 < }
8266 < _ACEOF
8267 < rm -f conftest.$ac_objext conftest$ac_exeext
8268 < if { (ac_try="$ac_link"
8269 < case "(($ac_try" in
8270 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8271 <  *) ac_try_echo=$ac_try;;
8272 < esac
8273 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8274 <  (eval "$ac_link") 2>conftest.er1
8275 <  ac_status=$?
8276 <  grep -v '^ *+' conftest.er1 >conftest.err
8277 <  rm -f conftest.er1
8278 <  cat conftest.err >&5
8279 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8280 <  (exit $ac_status); } && {
8281 <         test -z "$ac_c_werror_flag" ||
8282 <         test ! -s conftest.err
8283 <       } && test -s conftest$ac_exeext &&
8284 <       $as_test_x conftest$ac_exeext; then
8285 <  ac_cv_lib_fftw_fftwnd_one=yes
8286 < else
8287 <  echo "$as_me: failed program was:" >&5
8288 < sed 's/^/| /' conftest.$ac_ext >&5
8289 <
8290 <        ac_cv_lib_fftw_fftwnd_one=no
8291 < fi
8292 <
8293 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8294 <      conftest$ac_exeext conftest.$ac_ext
8295 < LIBS=$ac_check_lib_save_LIBS
8296 < fi
8297 < { echo "$as_me:$LINENO: result: $ac_cv_lib_fftw_fftwnd_one" >&5
8298 < echo "${ECHO_T}$ac_cv_lib_fftw_fftwnd_one" >&6; }
8299 < if test $ac_cv_lib_fftw_fftwnd_one = yes; then
8300 <  fftw_cv_libfftw=yes
8301 < else
8302 <  fftw_cv_libfftw=no
8303 < fi
8304 <
8305 <        if test "${ac_cv_header_fftw_h+set}" = set; then
8306 <  { echo "$as_me:$LINENO: checking for fftw.h" >&5
8307 < echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6; }
8308 < if test "${ac_cv_header_fftw_h+set}" = set; then
8309 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8310 < fi
8311 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
8312 < echo "${ECHO_T}$ac_cv_header_fftw_h" >&6; }
8313 < else
8314 <  # Is the header compilable?
8315 < { echo "$as_me:$LINENO: checking fftw.h usability" >&5
8316 < echo $ECHO_N "checking fftw.h usability... $ECHO_C" >&6; }
8317 < cat >conftest.$ac_ext <<_ACEOF
8318 < /* confdefs.h.  */
8319 < _ACEOF
8320 < cat confdefs.h >>conftest.$ac_ext
8321 < cat >>conftest.$ac_ext <<_ACEOF
8322 < /* end confdefs.h.  */
8323 < $ac_includes_default
8324 < #include <fftw.h>
8325 < _ACEOF
8326 < rm -f conftest.$ac_objext
8327 < if { (ac_try="$ac_compile"
8328 < case "(($ac_try" in
8329 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8330 <  *) ac_try_echo=$ac_try;;
8331 < esac
8332 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8333 <  (eval "$ac_compile") 2>conftest.er1
8334 <  ac_status=$?
8335 <  grep -v '^ *+' conftest.er1 >conftest.err
8336 <  rm -f conftest.er1
8337 <  cat conftest.err >&5
8338 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8339 <  (exit $ac_status); } && {
8340 <         test -z "$ac_c_werror_flag" ||
8341 <         test ! -s conftest.err
8342 <       } && test -s conftest.$ac_objext; then
8343 <  ac_header_compiler=yes
8344 < else
8345 <  echo "$as_me: failed program was:" >&5
8346 < sed 's/^/| /' conftest.$ac_ext >&5
8347 <
8348 <        ac_header_compiler=no
8349 < fi
8350 <
8351 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8352 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8353 < echo "${ECHO_T}$ac_header_compiler" >&6; }
8354 <
8355 < # Is the header present?
8356 < { echo "$as_me:$LINENO: checking fftw.h presence" >&5
8357 < echo $ECHO_N "checking fftw.h presence... $ECHO_C" >&6; }
8358 < cat >conftest.$ac_ext <<_ACEOF
8359 < /* confdefs.h.  */
8360 < _ACEOF
8361 < cat confdefs.h >>conftest.$ac_ext
8362 < cat >>conftest.$ac_ext <<_ACEOF
8363 < /* end confdefs.h.  */
8364 < #include <fftw.h>
8365 < _ACEOF
8366 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8367 < case "(($ac_try" in
8368 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8369 <  *) ac_try_echo=$ac_try;;
8370 < esac
8371 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8372 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8373 <  ac_status=$?
8374 <  grep -v '^ *+' conftest.er1 >conftest.err
8375 <  rm -f conftest.er1
8376 <  cat conftest.err >&5
8377 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8378 <  (exit $ac_status); } >/dev/null && {
8379 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8380 <         test ! -s conftest.err
8381 <       }; then
8382 <  ac_header_preproc=yes
8383 < else
8384 <  echo "$as_me: failed program was:" >&5
8385 < sed 's/^/| /' conftest.$ac_ext >&5
8386 <
8387 <  ac_header_preproc=no
8388 < fi
8389 <
8390 < rm -f conftest.err conftest.$ac_ext
8391 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8392 < echo "${ECHO_T}$ac_header_preproc" >&6; }
8393 <
8394 < # So?  What about this header?
8395 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8396 <  yes:no: )
8397 <    { echo "$as_me:$LINENO: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
8398 < echo "$as_me: WARNING: fftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8399 <    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the compiler's result" >&5
8400 < echo "$as_me: WARNING: fftw.h: proceeding with the compiler's result" >&2;}
8401 <    ac_header_preproc=yes
8402 <    ;;
8403 <  no:yes:* )
8404 <    { echo "$as_me:$LINENO: WARNING: fftw.h: present but cannot be compiled" >&5
8405 < echo "$as_me: WARNING: fftw.h: present but cannot be compiled" >&2;}
8406 <    { echo "$as_me:$LINENO: WARNING: fftw.h:     check for missing prerequisite headers?" >&5
8407 < echo "$as_me: WARNING: fftw.h:     check for missing prerequisite headers?" >&2;}
8408 <    { echo "$as_me:$LINENO: WARNING: fftw.h: see the Autoconf documentation" >&5
8409 < echo "$as_me: WARNING: fftw.h: see the Autoconf documentation" >&2;}
8410 <    { echo "$as_me:$LINENO: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&5
8411 < echo "$as_me: WARNING: fftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8412 <    { echo "$as_me:$LINENO: WARNING: fftw.h: proceeding with the preprocessor's result" >&5
8413 < echo "$as_me: WARNING: fftw.h: proceeding with the preprocessor's result" >&2;}
8414 <    { echo "$as_me:$LINENO: WARNING: fftw.h: in the future, the compiler will take precedence" >&5
8415 < echo "$as_me: WARNING: fftw.h: in the future, the compiler will take precedence" >&2;}
8416 <    ( cat <<\_ASBOX
8417 < ## ------------------------------ ##
8418 < ## Report this to gezelter@nd.edu ##
8419 < ## ------------------------------ ##
8420 < _ASBOX
8421 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8422 <    ;;
8423 < esac
8424 < { echo "$as_me:$LINENO: checking for fftw.h" >&5
8425 < echo $ECHO_N "checking for fftw.h... $ECHO_C" >&6; }
8426 < if test "${ac_cv_header_fftw_h+set}" = set; then
8427 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8428 < else
8429 <  ac_cv_header_fftw_h=$ac_header_preproc
8430 < fi
8431 < { echo "$as_me:$LINENO: result: $ac_cv_header_fftw_h" >&5
8432 < echo "${ECHO_T}$ac_cv_header_fftw_h" >&6; }
8433 <
8434 < fi
8435 < if test $ac_cv_header_fftw_h = yes; then
8436 <  fftw_cv_fftw_h=yes
8437 < else
8438 <  fftw_cv_fftw_h=no
8439 < fi
8440 <
8441 <
8442 <        if test "$fftw_cv_libfftw" = "no" -o "$fftw_cv_fftw_h" = "no"; then
8443 <          { echo "$as_me:$LINENO: checking for fftwnd_one in -ldfftw" >&5
8444 < echo $ECHO_N "checking for fftwnd_one in -ldfftw... $ECHO_C" >&6; }
8445 < if test "${ac_cv_lib_dfftw_fftwnd_one+set}" = set; then
8446 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8447 < else
8448 <  ac_check_lib_save_LIBS=$LIBS
8449 < LIBS="-ldfftw  $LIBS"
8450 < cat >conftest.$ac_ext <<_ACEOF
8451 < /* confdefs.h.  */
8452 < _ACEOF
8453 < cat confdefs.h >>conftest.$ac_ext
8454 < cat >>conftest.$ac_ext <<_ACEOF
8455 < /* end confdefs.h.  */
8456 <
8457 < /* Override any GCC internal prototype to avoid an error.
8458 <   Use char because int might match the return type of a GCC
8459 <   builtin and then its argument prototype would still apply.  */
8460 < #ifdef __cplusplus
8461 < extern "C"
8462 < #endif
8463 < char fftwnd_one ();
8464 < #ifdef FC_DUMMY_MAIN
8465 < #ifndef FC_DUMMY_MAIN_EQ_F77
8466 < #  ifdef __cplusplus
8467 <     extern "C"
8468 < #  endif
8469 <   int FC_DUMMY_MAIN() { return 1; }
8470 < #endif
8471 < #endif
8472 < int
8473 < main ()
8474 < {
8475 < return fftwnd_one ();
8476 <  ;
8477 <  return 0;
8478 < }
8479 < _ACEOF
8480 < rm -f conftest.$ac_objext conftest$ac_exeext
8481 < if { (ac_try="$ac_link"
8482 < case "(($ac_try" in
8483 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8484 <  *) ac_try_echo=$ac_try;;
8485 < esac
8486 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8487 <  (eval "$ac_link") 2>conftest.er1
8488 <  ac_status=$?
8489 <  grep -v '^ *+' conftest.er1 >conftest.err
8490 <  rm -f conftest.er1
8491 <  cat conftest.err >&5
8492 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8493 <  (exit $ac_status); } && {
8494 <         test -z "$ac_c_werror_flag" ||
8495 <         test ! -s conftest.err
8496 <       } && test -s conftest$ac_exeext &&
8497 <       $as_test_x conftest$ac_exeext; then
8498 <  ac_cv_lib_dfftw_fftwnd_one=yes
8499 < else
8500 <  echo "$as_me: failed program was:" >&5
8501 < sed 's/^/| /' conftest.$ac_ext >&5
8502 <
8503 <        ac_cv_lib_dfftw_fftwnd_one=no
8504 < fi
8505 <
8506 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8507 <      conftest$ac_exeext conftest.$ac_ext
8508 < LIBS=$ac_check_lib_save_LIBS
8509 < fi
8510 < { echo "$as_me:$LINENO: result: $ac_cv_lib_dfftw_fftwnd_one" >&5
8511 < echo "${ECHO_T}$ac_cv_lib_dfftw_fftwnd_one" >&6; }
8512 < if test $ac_cv_lib_dfftw_fftwnd_one = yes; then
8513 <  fftw_cv_libdfftw=yes
8514 < else
8515 <  fftw_cv_libdfftw=no
8516 < fi
8517 <
8518 <          if test "${ac_cv_header_dfftw_h+set}" = set; then
8519 <  { echo "$as_me:$LINENO: checking for dfftw.h" >&5
8520 < echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6; }
8521 < if test "${ac_cv_header_dfftw_h+set}" = set; then
8522 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8523 < fi
8524 < { echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
8525 < echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6; }
8526 < else
8527 <  # Is the header compilable?
8528 < { echo "$as_me:$LINENO: checking dfftw.h usability" >&5
8529 < echo $ECHO_N "checking dfftw.h usability... $ECHO_C" >&6; }
8530 < cat >conftest.$ac_ext <<_ACEOF
8531 < /* confdefs.h.  */
8532 < _ACEOF
8533 < cat confdefs.h >>conftest.$ac_ext
8534 < cat >>conftest.$ac_ext <<_ACEOF
8535 < /* end confdefs.h.  */
8536 < $ac_includes_default
8537 < #include <dfftw.h>
8538 < _ACEOF
8539 < rm -f conftest.$ac_objext
8540 < if { (ac_try="$ac_compile"
8541 < case "(($ac_try" in
8542 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8543 <  *) ac_try_echo=$ac_try;;
8544 < esac
8545 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8546 <  (eval "$ac_compile") 2>conftest.er1
8547 <  ac_status=$?
8548 <  grep -v '^ *+' conftest.er1 >conftest.err
8549 <  rm -f conftest.er1
8550 <  cat conftest.err >&5
8551 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8552 <  (exit $ac_status); } && {
8553 <         test -z "$ac_c_werror_flag" ||
8554 <         test ! -s conftest.err
8555 <       } && test -s conftest.$ac_objext; then
8556 <  ac_header_compiler=yes
8557 < else
8558 <  echo "$as_me: failed program was:" >&5
8559 < sed 's/^/| /' conftest.$ac_ext >&5
8560 <
8561 <        ac_header_compiler=no
8562 < fi
8563 <
8564 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8565 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8566 < echo "${ECHO_T}$ac_header_compiler" >&6; }
8567 <
8568 < # Is the header present?
8569 < { echo "$as_me:$LINENO: checking dfftw.h presence" >&5
8570 < echo $ECHO_N "checking dfftw.h presence... $ECHO_C" >&6; }
8571 < cat >conftest.$ac_ext <<_ACEOF
8572 < /* confdefs.h.  */
8573 < _ACEOF
8574 < cat confdefs.h >>conftest.$ac_ext
8575 < cat >>conftest.$ac_ext <<_ACEOF
8576 < /* end confdefs.h.  */
8577 < #include <dfftw.h>
8578 < _ACEOF
8579 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8580 < case "(($ac_try" in
8581 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8582 <  *) ac_try_echo=$ac_try;;
8583 < esac
8584 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8585 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8586 <  ac_status=$?
8587 <  grep -v '^ *+' conftest.er1 >conftest.err
8588 <  rm -f conftest.er1
8589 <  cat conftest.err >&5
8590 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8591 <  (exit $ac_status); } >/dev/null && {
8592 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8593 <         test ! -s conftest.err
8594 <       }; then
8595 <  ac_header_preproc=yes
8596 < else
8597 <  echo "$as_me: failed program was:" >&5
8598 < sed 's/^/| /' conftest.$ac_ext >&5
8599 <
8600 <  ac_header_preproc=no
8601 < fi
8602 <
8603 < rm -f conftest.err conftest.$ac_ext
8604 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8605 < echo "${ECHO_T}$ac_header_preproc" >&6; }
8606 <
8607 < # So?  What about this header?
8608 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8609 <  yes:no: )
8610 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&5
8611 < echo "$as_me: WARNING: dfftw.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8612 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the compiler's result" >&5
8613 < echo "$as_me: WARNING: dfftw.h: proceeding with the compiler's result" >&2;}
8614 <    ac_header_preproc=yes
8615 <    ;;
8616 <  no:yes:* )
8617 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: present but cannot be compiled" >&5
8618 < echo "$as_me: WARNING: dfftw.h: present but cannot be compiled" >&2;}
8619 <    { echo "$as_me:$LINENO: WARNING: dfftw.h:     check for missing prerequisite headers?" >&5
8620 < echo "$as_me: WARNING: dfftw.h:     check for missing prerequisite headers?" >&2;}
8621 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: see the Autoconf documentation" >&5
8622 < echo "$as_me: WARNING: dfftw.h: see the Autoconf documentation" >&2;}
8623 <    { echo "$as_me:$LINENO: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&5
8624 < echo "$as_me: WARNING: dfftw.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8625 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: proceeding with the preprocessor's result" >&5
8626 < echo "$as_me: WARNING: dfftw.h: proceeding with the preprocessor's result" >&2;}
8627 <    { echo "$as_me:$LINENO: WARNING: dfftw.h: in the future, the compiler will take precedence" >&5
8628 < echo "$as_me: WARNING: dfftw.h: in the future, the compiler will take precedence" >&2;}
8629 <    ( cat <<\_ASBOX
8630 < ## ------------------------------ ##
8631 < ## Report this to gezelter@nd.edu ##
8632 < ## ------------------------------ ##
8633 < _ASBOX
8634 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8635 <    ;;
8636 < esac
8637 < { echo "$as_me:$LINENO: checking for dfftw.h" >&5
8638 < echo $ECHO_N "checking for dfftw.h... $ECHO_C" >&6; }
8639 < if test "${ac_cv_header_dfftw_h+set}" = set; then
8640 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8641 < else
8642 <  ac_cv_header_dfftw_h=$ac_header_preproc
8643 < fi
8644 < { echo "$as_me:$LINENO: result: $ac_cv_header_dfftw_h" >&5
8645 < echo "${ECHO_T}$ac_cv_header_dfftw_h" >&6; }
8646 <
8647 < fi
8648 < if test $ac_cv_header_dfftw_h = yes; then
8649 <  fftw_cv_dfftw_h=yes
8650 < else
8651 <  fftw_cv_dfftw_h=no
8652 < fi
8653 <
8654 <
8655 <        fi
8656 <      fi
8657 <      ac_ext=c
8658 < ac_cpp='$CPP $CPPFLAGS'
8659 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8660 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8661 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8662 <
8663 <      if test "$fftw_cv_libfftw3" = "yes" -a "$fftw_cv_fftw3_h" = "yes"; then
8664 <
8665 < cat >>confdefs.h <<\_ACEOF
8666 < #define HAVE_FFTW3_H 1
8667 < _ACEOF
8668 <
8669 <        FFTW_INC_DIR="${FFTW_HOME}/include"
8670 <        FFTW_LIB_DIR="${FFTW_HOME}/lib"
8671 <        FFTW_LIBS="-lfftw3"
8672 <      else
8673 <        if test "$fftw_cv_libfftw" = "yes" -a "$fftw_cv_fftw_h" = "yes"; then
8674 <
8675 < cat >>confdefs.h <<\_ACEOF
8676 < #define HAVE_FFTW_H 1
8677 < _ACEOF
8678 <
8679 <          FFTW_INC_DIR="${FFTW_HOME}/include"
8680 <          FFTW_LIB_DIR="${FFTW_HOME}/lib"
8681 <          FFTW_LIBS="-lfftw"
8682 <        else
8683 <          if test "$fftw_cv_libdfftw" = "yes" -a "$fftw_cv_dfftw_h" = "yes"; then
8684 <
8685 < cat >>confdefs.h <<\_ACEOF
8686 < #define HAVE_DFFTW_H 1
8687 < _ACEOF
8688 <
8689 <            FFTW_INC_DIR="${FFTW_HOME}/include"
8690 <            FFTW_LIB_DIR="${FFTW_HOME}/lib"
8691 <            FFTW_LIBS="-ldfftw"
8692 <          else
8693 <            { echo "$as_me:$LINENO: checking fftw in ${FFTW_HOME}" >&5
8694 < echo $ECHO_N "checking fftw in ${FFTW_HOME}... $ECHO_C" >&6; }
8695 <            FFTW_INC_DIR=
8696 <            FFTW_LIB_DIR=
8697 <            FFTW_LIBS=
8698 <            LDFLAGS="$FFTW_OLD_LDFLAGS"
8699 <            CFLAGS="$FFTW_OLD_CFLAGS"
8700 <            { echo "$as_me:$LINENO: result: failed" >&5
8701 < echo "${ECHO_T}failed" >&6; }
8702 <            echo ""
8703 <            echo "*********************************************************"
8704 <            echo "* WARNING: Could not find a working FFTW installation   *"
8705 <            echo "* If you need the staticProps program to be able to     *"
8706 <            echo "* compute undulation spectra, be sure to specify a      *"
8707 <            echo "* valid fftw installation with --with-fftw=DIR          *"
8708 <            echo "*                                                       *"
8709 <            echo "* OOPSE will still work without fftw installed.         *"
8710 <            echo "*********************************************************"
8711 <            echo ""
8712 <          fi
8713 <        fi
8714 <      fi
8715 <
8716 <
8717 <
8718 <    fi
8719 <  fi
8720 < fi
8721 <
8722 < #
8723 < # Handle user hints
8724 < #
8725 <
8726 < # Check whether --with-qhull was given.
8727 < if test "${with_qhull+set}" = set; then
8728 <  withval=$with_qhull; qhull_dir="$withval"
8729 < else
8730 <                qhull_dir="not_set"
8731 < fi
8732 <
8733 < if test "$qhull_dir" != "no"; then
8734 <
8735 < if test "$qhull_dir" != "not_set" ; then
8736 <  if test -d "$qhull_dir"
8737 <  then
8738 <    QHULL_HOME="$qhull_dir"
8739 <  else
8740 <    { echo "$as_me:$LINENO: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&5
8741 < echo "$as_me: WARNING: Sorry, $qhull_dir does not exist, checking usual places" >&2;}
8742 <        QHULL_HOME=/usr/local
8743 <        if test ! -f "${QHULL_HOME}/include/qhull/qhull.h"
8744 <        then
8745 <                QHULL_HOME=/usr
8746 <        fi
8747 <  fi
8748 < fi
8749 < #
8750 < # Locate qhull, if wanted
8751 < #
8752 < if test -n "${QHULL_HOME}"
8753 < then
8754 <
8755 <        ac_ext=c
8756 < ac_cpp='$CPP $CPPFLAGS'
8757 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8758 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8759 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8760 <
8761 <        QHULL_OLD_LDFLAGS=$LDFLAGS
8762 <        QHULL_OLD_CFLAGS=$CFLAGS
8763 <        QHULL_OLD_CPPFLAGS=$CPPFLAGS
8764 <        LDFLAGS="$LDFLAGS -L${QHULL_HOME}/lib"
8765 <        CFLAGS="$CFLAGS -I${QHULL_HOME}/include"
8766 <        CPPFLAGS="$CPPFLAGS -I${QHULL_HOME}/include"
8767 <        if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8768 <  { echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
8769 < echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6; }
8770 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8771 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8772 < fi
8773 < { echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
8774 < echo "${ECHO_T}$ac_cv_header_qhull_qhull_h" >&6; }
8775 < else
8776 <  # Is the header compilable?
8777 < { echo "$as_me:$LINENO: checking qhull/qhull.h usability" >&5
8778 < echo $ECHO_N "checking qhull/qhull.h usability... $ECHO_C" >&6; }
8779 < cat >conftest.$ac_ext <<_ACEOF
8780 < /* confdefs.h.  */
8781 < _ACEOF
8782 < cat confdefs.h >>conftest.$ac_ext
8783 < cat >>conftest.$ac_ext <<_ACEOF
8784 < /* end confdefs.h.  */
8785 < $ac_includes_default
8786 < #include <qhull/qhull.h>
8787 < _ACEOF
8788 < rm -f conftest.$ac_objext
8789 < if { (ac_try="$ac_compile"
8790 < case "(($ac_try" in
8791 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8792 <  *) ac_try_echo=$ac_try;;
8793 < esac
8794 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8795 <  (eval "$ac_compile") 2>conftest.er1
8796 <  ac_status=$?
8797 <  grep -v '^ *+' conftest.er1 >conftest.err
8798 <  rm -f conftest.er1
8799 <  cat conftest.err >&5
8800 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8801 <  (exit $ac_status); } && {
8802 <         test -z "$ac_c_werror_flag" ||
8803 <         test ! -s conftest.err
8804 <       } && test -s conftest.$ac_objext; then
8805 <  ac_header_compiler=yes
8806 < else
8807 <  echo "$as_me: failed program was:" >&5
8808 < sed 's/^/| /' conftest.$ac_ext >&5
8809 <
8810 <        ac_header_compiler=no
8811 < fi
8812 <
8813 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
8814 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
8815 < echo "${ECHO_T}$ac_header_compiler" >&6; }
8816 <
8817 < # Is the header present?
8818 < { echo "$as_me:$LINENO: checking qhull/qhull.h presence" >&5
8819 < echo $ECHO_N "checking qhull/qhull.h presence... $ECHO_C" >&6; }
8820 < cat >conftest.$ac_ext <<_ACEOF
8821 < /* confdefs.h.  */
8822 < _ACEOF
8823 < cat confdefs.h >>conftest.$ac_ext
8824 < cat >>conftest.$ac_ext <<_ACEOF
8825 < /* end confdefs.h.  */
8826 < #include <qhull/qhull.h>
8827 < _ACEOF
8828 < if { (ac_try="$ac_cpp conftest.$ac_ext"
8829 < case "(($ac_try" in
8830 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8831 <  *) ac_try_echo=$ac_try;;
8832 < esac
8833 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8834 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
8835 <  ac_status=$?
8836 <  grep -v '^ *+' conftest.er1 >conftest.err
8837 <  rm -f conftest.er1
8838 <  cat conftest.err >&5
8839 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8840 <  (exit $ac_status); } >/dev/null && {
8841 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
8842 <         test ! -s conftest.err
8843 <       }; then
8844 <  ac_header_preproc=yes
8845 < else
8846 <  echo "$as_me: failed program was:" >&5
8847 < sed 's/^/| /' conftest.$ac_ext >&5
8848 <
8849 <  ac_header_preproc=no
8850 < fi
8851 <
8852 < rm -f conftest.err conftest.$ac_ext
8853 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
8854 < echo "${ECHO_T}$ac_header_preproc" >&6; }
8855 <
8856 < # So?  What about this header?
8857 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
8858 <  yes:no: )
8859 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&5
8860 < echo "$as_me: WARNING: qhull/qhull.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
8861 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&5
8862 < echo "$as_me: WARNING: qhull/qhull.h: proceeding with the compiler's result" >&2;}
8863 <    ac_header_preproc=yes
8864 <    ;;
8865 <  no:yes:* )
8866 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: present but cannot be compiled" >&5
8867 < echo "$as_me: WARNING: qhull/qhull.h: present but cannot be compiled" >&2;}
8868 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&5
8869 < echo "$as_me: WARNING: qhull/qhull.h:     check for missing prerequisite headers?" >&2;}
8870 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: see the Autoconf documentation" >&5
8871 < echo "$as_me: WARNING: qhull/qhull.h: see the Autoconf documentation" >&2;}
8872 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&5
8873 < echo "$as_me: WARNING: qhull/qhull.h:     section \"Present But Cannot Be Compiled\"" >&2;}
8874 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&5
8875 < echo "$as_me: WARNING: qhull/qhull.h: proceeding with the preprocessor's result" >&2;}
8876 <    { echo "$as_me:$LINENO: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&5
8877 < echo "$as_me: WARNING: qhull/qhull.h: in the future, the compiler will take precedence" >&2;}
8878 <    ( cat <<\_ASBOX
8879 < ## ------------------------------ ##
8880 < ## Report this to gezelter@nd.edu ##
8881 < ## ------------------------------ ##
8882 < _ASBOX
8883 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
8884 <    ;;
8885 < esac
8886 < { echo "$as_me:$LINENO: checking for qhull/qhull.h" >&5
8887 < echo $ECHO_N "checking for qhull/qhull.h... $ECHO_C" >&6; }
8888 < if test "${ac_cv_header_qhull_qhull_h+set}" = set; then
8889 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8890 < else
8891 <  ac_cv_header_qhull_qhull_h=$ac_header_preproc
8892 < fi
8893 < { echo "$as_me:$LINENO: result: $ac_cv_header_qhull_qhull_h" >&5
8894 < echo "${ECHO_T}$ac_cv_header_qhull_qhull_h" >&6; }
8895 <
8896 < fi
8897 < if test $ac_cv_header_qhull_qhull_h = yes; then
8898 <  qhull_cv_qhull_h=yes
8899 < else
8900 <  qhull_cv_qhull_h=no
8901 < fi
8902 <
8903 <
8904 <        { echo "$as_me:$LINENO: checking for qh_qhull in -lqhull" >&5
8905 < echo $ECHO_N "checking for qh_qhull in -lqhull... $ECHO_C" >&6; }
8906 < if test "${ac_cv_lib_qhull_qh_qhull+set}" = set; then
8907 <  echo $ECHO_N "(cached) $ECHO_C" >&6
8908 < else
8909 <  ac_check_lib_save_LIBS=$LIBS
8910 < LIBS="-lqhull  $LIBS"
8911 < cat >conftest.$ac_ext <<_ACEOF
8912 < /* confdefs.h.  */
8913 < _ACEOF
8914 < cat confdefs.h >>conftest.$ac_ext
8915 < cat >>conftest.$ac_ext <<_ACEOF
8916 < /* end confdefs.h.  */
8917 <
8918 < /* Override any GCC internal prototype to avoid an error.
8919 <   Use char because int might match the return type of a GCC
8920 <   builtin and then its argument prototype would still apply.  */
8921 < #ifdef __cplusplus
8922 < extern "C"
8923 < #endif
8924 < char qh_qhull ();
8925 < #ifdef FC_DUMMY_MAIN
8926 < #ifndef FC_DUMMY_MAIN_EQ_F77
8927 < #  ifdef __cplusplus
8928 <     extern "C"
8929 < #  endif
8930 <   int FC_DUMMY_MAIN() { return 1; }
8931 < #endif
8932 < #endif
8933 < int
8934 < main ()
8935 < {
8936 < return qh_qhull ();
8937 <  ;
8938 <  return 0;
8939 < }
8940 < _ACEOF
8941 < rm -f conftest.$ac_objext conftest$ac_exeext
8942 < if { (ac_try="$ac_link"
8943 < case "(($ac_try" in
8944 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
8945 <  *) ac_try_echo=$ac_try;;
8946 < esac
8947 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
8948 <  (eval "$ac_link") 2>conftest.er1
8949 <  ac_status=$?
8950 <  grep -v '^ *+' conftest.er1 >conftest.err
8951 <  rm -f conftest.er1
8952 <  cat conftest.err >&5
8953 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
8954 <  (exit $ac_status); } && {
8955 <         test -z "$ac_c_werror_flag" ||
8956 <         test ! -s conftest.err
8957 <       } && test -s conftest$ac_exeext &&
8958 <       $as_test_x conftest$ac_exeext; then
8959 <  ac_cv_lib_qhull_qh_qhull=yes
8960 < else
8961 <  echo "$as_me: failed program was:" >&5
8962 < sed 's/^/| /' conftest.$ac_ext >&5
8963 <
8964 <        ac_cv_lib_qhull_qh_qhull=no
8965 < fi
8966 <
8967 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
8968 <      conftest$ac_exeext conftest.$ac_ext
8969 < LIBS=$ac_check_lib_save_LIBS
8970 < fi
8971 < { echo "$as_me:$LINENO: result: $ac_cv_lib_qhull_qh_qhull" >&5
8972 < echo "${ECHO_T}$ac_cv_lib_qhull_qh_qhull" >&6; }
8973 < if test $ac_cv_lib_qhull_qh_qhull = yes; then
8974 <  qhull_cv_libqhull=yes
8975 < else
8976 <  qhull_cv_libqhull=no
8977 < fi
8978 <
8979 <        LDFLAGS="$QHULL_OLD_LDFLAGS"
8980 <        CFLAGS="$QHULL_OLD_CFLAGS"
8981 <        CPPFLAGS="$QHULL_OLD_CPPFLAGS"
8982 <        ac_ext=c
8983 < ac_cpp='$CPP $CPPFLAGS'
8984 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
8985 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
8986 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
8987 <
8988 <
8989 <        if test "$qhull_cv_libqhull" = "yes" -a "$qhull_cv_qhull_h" = "yes"; then
8990 <
8991 < cat >>confdefs.h <<\_ACEOF
8992 < #define HAVE_QHULL_H 1
8993 < _ACEOF
8994 <
8995 <
8996 < cat >>confdefs.h <<\_ACEOF
8997 < #define HAVE_QHULL 1
8998 < _ACEOF
8999 <
9000 <                USE_QHULL=yes
9001 <                QHULL_INC_DIR="${QHULL_HOME}/include"
9002 <                QHULL_LIB_DIR="${QHULL_HOME}/lib"
9003 <                QHULL="-lqhull"
9004 <        else
9005 <                { echo "$as_me:$LINENO: checking qhull in ${QHULL_HOME}" >&5
9006 < echo $ECHO_N "checking qhull in ${QHULL_HOME}... $ECHO_C" >&6; }
9007 <                QHULL_INC_DIR=
9008 <                QHULL_LIB_DIR=
9009 <                QHULL=
9010 <                USE_QHULL=no
9011 <                { echo "$as_me:$LINENO: result: failed" >&5
9012 < echo "${ECHO_T}failed" >&6; }
9013 <                echo ""
9014 <                echo "*********************************************************"
9015 <                echo "* WARNING: Could not find a working qhull installation  *"
9016 <                echo "* If you need OOPSE to be able to deal with convex      *"
9017 <                echo "* hulls be sure to specify a valid qhull installation   *"
9018 <                echo "* with --with-qhull=DIR                                 *"
9019 <                echo "*                                                       *"
9020 <                echo "* OOPSE will still work without qhull installed.        *"
9021 <                echo "*********************************************************"
9022 <                echo ""
9023 <        fi
9024 <
9025 <
9026 <
9027 <
9028 < fi
9029 < fi
9030 <
9031 <
9032 < ac_ext=cpp
9033 < ac_cpp='$CXXCPP $CPPFLAGS'
9034 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9035 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9036 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9037 < { echo "$as_me:$LINENO: checking how to run the C++ preprocessor" >&5
9038 < echo $ECHO_N "checking how to run the C++ preprocessor... $ECHO_C" >&6; }
9039 < if test -z "$CXXCPP"; then
9040 <  if test "${ac_cv_prog_CXXCPP+set}" = set; then
9041 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9042 < else
9043 <      # Double quotes because CXXCPP needs to be expanded
9044 <    for CXXCPP in "$CXX -E" "/lib/cpp"
9045 <    do
9046 <      ac_preproc_ok=false
9047 < for ac_cxx_preproc_warn_flag in '' yes
9048 < do
9049 <  # Use a header file that comes with gcc, so configuring glibc
9050 <  # with a fresh cross-compiler works.
9051 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9052 <  # <limits.h> exists even on freestanding compilers.
9053 <  # On the NeXT, cc -E runs the code through the compiler's parser,
9054 <  # not just through cpp. "Syntax error" is here to catch this case.
9055 <  cat >conftest.$ac_ext <<_ACEOF
9056 < /* confdefs.h.  */
9057 < _ACEOF
9058 < cat confdefs.h >>conftest.$ac_ext
9059 < cat >>conftest.$ac_ext <<_ACEOF
9060 < /* end confdefs.h.  */
9061 < #ifdef __STDC__
9062 < # include <limits.h>
9063 < #else
9064 < # include <assert.h>
9065 < #endif
9066 <                     Syntax error
9067 < _ACEOF
9068 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9069 < case "(($ac_try" in
9070 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9071 <  *) ac_try_echo=$ac_try;;
9072 < esac
9073 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9074 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9075 <  ac_status=$?
9076 <  grep -v '^ *+' conftest.er1 >conftest.err
9077 <  rm -f conftest.er1
9078 <  cat conftest.err >&5
9079 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9080 <  (exit $ac_status); } >/dev/null && {
9081 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9082 <         test ! -s conftest.err
9083 <       }; then
9084 <  :
9085 < else
9086 <  echo "$as_me: failed program was:" >&5
9087 < sed 's/^/| /' conftest.$ac_ext >&5
9088 <
9089 <  # Broken: fails on valid input.
9090 < continue
9091 < fi
9092 <
9093 < rm -f conftest.err conftest.$ac_ext
9094 <
9095 <  # OK, works on sane cases.  Now check whether nonexistent headers
9096 <  # can be detected and how.
9097 <  cat >conftest.$ac_ext <<_ACEOF
9098 < /* confdefs.h.  */
9099 < _ACEOF
9100 < cat confdefs.h >>conftest.$ac_ext
9101 < cat >>conftest.$ac_ext <<_ACEOF
9102 < /* end confdefs.h.  */
9103 < #include <ac_nonexistent.h>
9104 < _ACEOF
9105 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9106 < case "(($ac_try" in
9107 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9108 <  *) ac_try_echo=$ac_try;;
9109 < esac
9110 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9111 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9112 <  ac_status=$?
9113 <  grep -v '^ *+' conftest.er1 >conftest.err
9114 <  rm -f conftest.er1
9115 <  cat conftest.err >&5
9116 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9117 <  (exit $ac_status); } >/dev/null && {
9118 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9119 <         test ! -s conftest.err
9120 <       }; then
9121 <  # Broken: success on invalid input.
9122 < continue
9123 < else
9124 <  echo "$as_me: failed program was:" >&5
9125 < sed 's/^/| /' conftest.$ac_ext >&5
9126 <
9127 <  # Passes both tests.
9128 < ac_preproc_ok=:
9129 < break
9130 < fi
9131 <
9132 < rm -f conftest.err conftest.$ac_ext
9133 <
9134 < done
9135 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9136 < rm -f conftest.err conftest.$ac_ext
9137 < if $ac_preproc_ok; then
9138 <  break
9139 < fi
9140 <
9141 <    done
9142 <    ac_cv_prog_CXXCPP=$CXXCPP
9143 <
9144 < fi
9145 <  CXXCPP=$ac_cv_prog_CXXCPP
9146 < else
9147 <  ac_cv_prog_CXXCPP=$CXXCPP
9148 < fi
9149 < { echo "$as_me:$LINENO: result: $CXXCPP" >&5
9150 < echo "${ECHO_T}$CXXCPP" >&6; }
9151 < ac_preproc_ok=false
9152 < for ac_cxx_preproc_warn_flag in '' yes
9153 < do
9154 <  # Use a header file that comes with gcc, so configuring glibc
9155 <  # with a fresh cross-compiler works.
9156 <  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
9157 <  # <limits.h> exists even on freestanding compilers.
9158 <  # On the NeXT, cc -E runs the code through the compiler's parser,
9159 <  # not just through cpp. "Syntax error" is here to catch this case.
9160 <  cat >conftest.$ac_ext <<_ACEOF
9161 < /* confdefs.h.  */
9162 < _ACEOF
9163 < cat confdefs.h >>conftest.$ac_ext
9164 < cat >>conftest.$ac_ext <<_ACEOF
9165 < /* end confdefs.h.  */
9166 < #ifdef __STDC__
9167 < # include <limits.h>
9168 < #else
9169 < # include <assert.h>
9170 < #endif
9171 <                     Syntax error
9172 < _ACEOF
9173 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9174 < case "(($ac_try" in
9175 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9176 <  *) ac_try_echo=$ac_try;;
9177 < esac
9178 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9179 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9180 <  ac_status=$?
9181 <  grep -v '^ *+' conftest.er1 >conftest.err
9182 <  rm -f conftest.er1
9183 <  cat conftest.err >&5
9184 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9185 <  (exit $ac_status); } >/dev/null && {
9186 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9187 <         test ! -s conftest.err
9188 <       }; then
9189 <  :
9190 < else
9191 <  echo "$as_me: failed program was:" >&5
9192 < sed 's/^/| /' conftest.$ac_ext >&5
9193 <
9194 <  # Broken: fails on valid input.
9195 < continue
9196 < fi
9197 <
9198 < rm -f conftest.err conftest.$ac_ext
9199 <
9200 <  # OK, works on sane cases.  Now check whether nonexistent headers
9201 <  # can be detected and how.
9202 <  cat >conftest.$ac_ext <<_ACEOF
9203 < /* confdefs.h.  */
9204 < _ACEOF
9205 < cat confdefs.h >>conftest.$ac_ext
9206 < cat >>conftest.$ac_ext <<_ACEOF
9207 < /* end confdefs.h.  */
9208 < #include <ac_nonexistent.h>
9209 < _ACEOF
9210 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9211 < case "(($ac_try" in
9212 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9213 <  *) ac_try_echo=$ac_try;;
9214 < esac
9215 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9216 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9217 <  ac_status=$?
9218 <  grep -v '^ *+' conftest.er1 >conftest.err
9219 <  rm -f conftest.er1
9220 <  cat conftest.err >&5
9221 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9222 <  (exit $ac_status); } >/dev/null && {
9223 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9224 <         test ! -s conftest.err
9225 <       }; then
9226 <  # Broken: success on invalid input.
9227 < continue
9228 < else
9229 <  echo "$as_me: failed program was:" >&5
9230 < sed 's/^/| /' conftest.$ac_ext >&5
9231 <
9232 <  # Passes both tests.
9233 < ac_preproc_ok=:
9234 < break
9235 < fi
9236 <
9237 < rm -f conftest.err conftest.$ac_ext
9238 <
9239 < done
9240 < # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
9241 < rm -f conftest.err conftest.$ac_ext
9242 < if $ac_preproc_ok; then
9243 <  :
9244 < else
9245 <  { { echo "$as_me:$LINENO: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9246 < See \`config.log' for more details." >&5
9247 < echo "$as_me: error: C++ preprocessor \"$CXXCPP\" fails sanity check
9248 < See \`config.log' for more details." >&2;}
9249 <   { (exit 1); exit 1; }; }
9250 < fi
9251 <
9252 < ac_ext=cpp
9253 < ac_cpp='$CXXCPP $CPPFLAGS'
9254 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9255 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9256 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9257 <
9258 <
9259 < #
9260 < # Handle user hints
9261 < #
9262 <
9263 < # Check whether --with-openbabel was given.
9264 < if test "${with_openbabel+set}" = set; then
9265 <  withval=$with_openbabel; openbabel_dir="$withval"
9266 < else
9267 <                openbabel_dir="not_set"
9268 < fi
9269 <
9270 < if test "$openbabel_dir" != "no"; then
9271 <
9272 < if test "$openbabel_dir" != "not_set" ; then
9273 <  if test -d "$openbabel_dir"
9274 <  then
9275 <    OPENBABEL_HOME="$openbabel_dir"
9276 <  else
9277 <    { echo "$as_me:$LINENO: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&5
9278 < echo "$as_me: WARNING: Sorry, $openbabel_dir does not exist, checking usual places" >&2;}
9279 <        OPENBABEL_HOME=/usr/local
9280 <        if test ! -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/babelconfig.h" -a -f "${OPENBABEL_HOME}/include/openbabel-2.0/openbabel/obconversion.h"
9281 <        then
9282 <                OPENBABEL_HOME=/usr
9283 <        fi
9284 <  fi
9285 < fi
9286 < #
9287 < # Locate openbabel, if wanted
9288 < #
9289 < if test -n "${OPENBABEL_HOME}"
9290 < then
9291 <
9292 <        ac_ext=cpp
9293 < ac_cpp='$CXXCPP $CPPFLAGS'
9294 < ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9295 < ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9296 < ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
9297 <
9298 <        OPENBABEL_OLD_LDFLAGS=$LDFLAGS
9299 <        OPENBABEL_OLD_CPPFLAGS=$CPPFLAGS
9300 <        LDFLAGS="$LDFLAGS -L${OPENBABEL_HOME}/lib -lopenbabel"
9301 <        CPPFLAGS="$CPPFLAGS -I${OPENBABEL_HOME}/include/openbabel-2.0"
9302 <        if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9303 <  { echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9304 < echo $ECHO_N "checking for openbabel/babelconfig.h... $ECHO_C" >&6; }
9305 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9306 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9307 < fi
9308 < { echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9309 < echo "${ECHO_T}$ac_cv_header_openbabel_babelconfig_h" >&6; }
9310 < else
9311 <  # Is the header compilable?
9312 < { echo "$as_me:$LINENO: checking openbabel/babelconfig.h usability" >&5
9313 < echo $ECHO_N "checking openbabel/babelconfig.h usability... $ECHO_C" >&6; }
9314 < cat >conftest.$ac_ext <<_ACEOF
9315 < /* confdefs.h.  */
9316 < _ACEOF
9317 < cat confdefs.h >>conftest.$ac_ext
9318 < cat >>conftest.$ac_ext <<_ACEOF
9319 < /* end confdefs.h.  */
9320 < $ac_includes_default
9321 < #include <openbabel/babelconfig.h>
9322 < _ACEOF
9323 < rm -f conftest.$ac_objext
9324 < if { (ac_try="$ac_compile"
9325 < case "(($ac_try" in
9326 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9327 <  *) ac_try_echo=$ac_try;;
9328 < esac
9329 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9330 <  (eval "$ac_compile") 2>conftest.er1
9331 <  ac_status=$?
9332 <  grep -v '^ *+' conftest.er1 >conftest.err
9333 <  rm -f conftest.er1
9334 <  cat conftest.err >&5
9335 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9336 <  (exit $ac_status); } && {
9337 <         test -z "$ac_cxx_werror_flag" ||
9338 <         test ! -s conftest.err
9339 <       } && test -s conftest.$ac_objext; then
9340 <  ac_header_compiler=yes
9341 < else
9342 <  echo "$as_me: failed program was:" >&5
9343 < sed 's/^/| /' conftest.$ac_ext >&5
9344 <
9345 <        ac_header_compiler=no
9346 < fi
9347 <
9348 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9349 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9350 < echo "${ECHO_T}$ac_header_compiler" >&6; }
9351 <
9352 < # Is the header present?
9353 < { echo "$as_me:$LINENO: checking openbabel/babelconfig.h presence" >&5
9354 < echo $ECHO_N "checking openbabel/babelconfig.h presence... $ECHO_C" >&6; }
9355 < cat >conftest.$ac_ext <<_ACEOF
9356 < /* confdefs.h.  */
9357 < _ACEOF
9358 < cat confdefs.h >>conftest.$ac_ext
9359 < cat >>conftest.$ac_ext <<_ACEOF
9360 < /* end confdefs.h.  */
9361 < #include <openbabel/babelconfig.h>
9362 < _ACEOF
9363 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9364 < case "(($ac_try" in
9365 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9366 <  *) ac_try_echo=$ac_try;;
9367 < esac
9368 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9369 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9370 <  ac_status=$?
9371 <  grep -v '^ *+' conftest.er1 >conftest.err
9372 <  rm -f conftest.er1
9373 <  cat conftest.err >&5
9374 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9375 <  (exit $ac_status); } >/dev/null && {
9376 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9377 <         test ! -s conftest.err
9378 <       }; then
9379 <  ac_header_preproc=yes
9380 < else
9381 <  echo "$as_me: failed program was:" >&5
9382 < sed 's/^/| /' conftest.$ac_ext >&5
9383 <
9384 <  ac_header_preproc=no
9385 < fi
9386 <
9387 < rm -f conftest.err conftest.$ac_ext
9388 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9389 < echo "${ECHO_T}$ac_header_preproc" >&6; }
9390 <
9391 < # So?  What about this header?
9392 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9393 <  yes:no: )
9394 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&5
9395 < echo "$as_me: WARNING: openbabel/babelconfig.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9396 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&5
9397 < echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the compiler's result" >&2;}
9398 <    ac_header_preproc=yes
9399 <    ;;
9400 <  no:yes:* )
9401 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&5
9402 < echo "$as_me: WARNING: openbabel/babelconfig.h: present but cannot be compiled" >&2;}
9403 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&5
9404 < echo "$as_me: WARNING: openbabel/babelconfig.h:     check for missing prerequisite headers?" >&2;}
9405 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&5
9406 < echo "$as_me: WARNING: openbabel/babelconfig.h: see the Autoconf documentation" >&2;}
9407 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&5
9408 < echo "$as_me: WARNING: openbabel/babelconfig.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9409 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&5
9410 < echo "$as_me: WARNING: openbabel/babelconfig.h: proceeding with the preprocessor's result" >&2;}
9411 <    { echo "$as_me:$LINENO: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&5
9412 < echo "$as_me: WARNING: openbabel/babelconfig.h: in the future, the compiler will take precedence" >&2;}
9413 <    ( cat <<\_ASBOX
9414 < ## ------------------------------ ##
9415 < ## Report this to gezelter@nd.edu ##
9416 < ## ------------------------------ ##
9417 < _ASBOX
9418 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9419 <    ;;
9420 < esac
9421 < { echo "$as_me:$LINENO: checking for openbabel/babelconfig.h" >&5
9422 < echo $ECHO_N "checking for openbabel/babelconfig.h... $ECHO_C" >&6; }
9423 < if test "${ac_cv_header_openbabel_babelconfig_h+set}" = set; then
9424 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9425 < else
9426 <  ac_cv_header_openbabel_babelconfig_h=$ac_header_preproc
9427 < fi
9428 < { echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_babelconfig_h" >&5
9429 < echo "${ECHO_T}$ac_cv_header_openbabel_babelconfig_h" >&6; }
9430 <
9431 < fi
9432 < if test $ac_cv_header_openbabel_babelconfig_h = yes; then
9433 <  openbabel_cv_openbabel_h=yes
9434 < else
9435 <  openbabel_cv_openbabel_h=no
9436 < fi
9437 <
9438 <
9439 <        if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9440 <  { echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9441 < echo $ECHO_N "checking for openbabel/obconversion.h... $ECHO_C" >&6; }
9442 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9443 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9444 < fi
9445 < { echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9446 < echo "${ECHO_T}$ac_cv_header_openbabel_obconversion_h" >&6; }
9447 < else
9448 <  # Is the header compilable?
9449 < { echo "$as_me:$LINENO: checking openbabel/obconversion.h usability" >&5
9450 < echo $ECHO_N "checking openbabel/obconversion.h usability... $ECHO_C" >&6; }
9451 < cat >conftest.$ac_ext <<_ACEOF
9452 < /* confdefs.h.  */
9453 < _ACEOF
9454 < cat confdefs.h >>conftest.$ac_ext
9455 < cat >>conftest.$ac_ext <<_ACEOF
9456 < /* end confdefs.h.  */
9457 < $ac_includes_default
9458 < #include <openbabel/obconversion.h>
9459 < _ACEOF
9460 < rm -f conftest.$ac_objext
9461 < if { (ac_try="$ac_compile"
9462 < case "(($ac_try" in
9463 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9464 <  *) ac_try_echo=$ac_try;;
9465 < esac
9466 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9467 <  (eval "$ac_compile") 2>conftest.er1
9468 <  ac_status=$?
9469 <  grep -v '^ *+' conftest.er1 >conftest.err
9470 <  rm -f conftest.er1
9471 <  cat conftest.err >&5
9472 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9473 <  (exit $ac_status); } && {
9474 <         test -z "$ac_cxx_werror_flag" ||
9475 <         test ! -s conftest.err
9476 <       } && test -s conftest.$ac_objext; then
9477 <  ac_header_compiler=yes
9478 < else
9479 <  echo "$as_me: failed program was:" >&5
9480 < sed 's/^/| /' conftest.$ac_ext >&5
9481 <
9482 <        ac_header_compiler=no
9483 < fi
9484 <
9485 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9486 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9487 < echo "${ECHO_T}$ac_header_compiler" >&6; }
9488 <
9489 < # Is the header present?
9490 < { echo "$as_me:$LINENO: checking openbabel/obconversion.h presence" >&5
9491 < echo $ECHO_N "checking openbabel/obconversion.h presence... $ECHO_C" >&6; }
9492 < cat >conftest.$ac_ext <<_ACEOF
9493 < /* confdefs.h.  */
9494 < _ACEOF
9495 < cat confdefs.h >>conftest.$ac_ext
9496 < cat >>conftest.$ac_ext <<_ACEOF
9497 < /* end confdefs.h.  */
9498 < #include <openbabel/obconversion.h>
9499 < _ACEOF
9500 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9501 < case "(($ac_try" in
9502 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9503 <  *) ac_try_echo=$ac_try;;
9504 < esac
9505 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9506 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9507 <  ac_status=$?
9508 <  grep -v '^ *+' conftest.er1 >conftest.err
9509 <  rm -f conftest.er1
9510 <  cat conftest.err >&5
9511 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9512 <  (exit $ac_status); } >/dev/null && {
9513 <         test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
9514 <         test ! -s conftest.err
9515 <       }; then
9516 <  ac_header_preproc=yes
9517 < else
9518 <  echo "$as_me: failed program was:" >&5
9519 < sed 's/^/| /' conftest.$ac_ext >&5
9520 <
9521 <  ac_header_preproc=no
9522 < fi
9523 <
9524 < rm -f conftest.err conftest.$ac_ext
9525 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9526 < echo "${ECHO_T}$ac_header_preproc" >&6; }
9527 <
9528 < # So?  What about this header?
9529 < case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in
9530 <  yes:no: )
9531 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&5
9532 < echo "$as_me: WARNING: openbabel/obconversion.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
9533 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&5
9534 < echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the compiler's result" >&2;}
9535 <    ac_header_preproc=yes
9536 <    ;;
9537 <  no:yes:* )
9538 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&5
9539 < echo "$as_me: WARNING: openbabel/obconversion.h: present but cannot be compiled" >&2;}
9540 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&5
9541 < echo "$as_me: WARNING: openbabel/obconversion.h:     check for missing prerequisite headers?" >&2;}
9542 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&5
9543 < echo "$as_me: WARNING: openbabel/obconversion.h: see the Autoconf documentation" >&2;}
9544 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&5
9545 < echo "$as_me: WARNING: openbabel/obconversion.h:     section \"Present But Cannot Be Compiled\"" >&2;}
9546 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&5
9547 < echo "$as_me: WARNING: openbabel/obconversion.h: proceeding with the preprocessor's result" >&2;}
9548 <    { echo "$as_me:$LINENO: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&5
9549 < echo "$as_me: WARNING: openbabel/obconversion.h: in the future, the compiler will take precedence" >&2;}
9550 <    ( cat <<\_ASBOX
9551 < ## ------------------------------ ##
9552 < ## Report this to gezelter@nd.edu ##
9553 < ## ------------------------------ ##
9554 < _ASBOX
9555 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
9556 <    ;;
9557 < esac
9558 < { echo "$as_me:$LINENO: checking for openbabel/obconversion.h" >&5
9559 < echo $ECHO_N "checking for openbabel/obconversion.h... $ECHO_C" >&6; }
9560 < if test "${ac_cv_header_openbabel_obconversion_h+set}" = set; then
9561 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9562 < else
9563 <  ac_cv_header_openbabel_obconversion_h=$ac_header_preproc
9564 < fi
9565 < { echo "$as_me:$LINENO: result: $ac_cv_header_openbabel_obconversion_h" >&5
9566 < echo "${ECHO_T}$ac_cv_header_openbabel_obconversion_h" >&6; }
9567 <
9568 < fi
9569 < if test $ac_cv_header_openbabel_obconversion_h = yes; then
9570 <  openbabel_cv_obconversion_h=yes
9571 < else
9572 <  openbabel_cv_obconversion_h=no
9573 < fi
9574 <
9575 <
9576 <        cat >conftest.$ac_ext <<_ACEOF
9577 <
9578 <             /* confdefs.h.  */
9579 < _ACEOF
9580 < cat confdefs.h >>conftest.$ac_ext
9581 < cat >>conftest.$ac_ext <<_ACEOF
9582 < /* end confdefs.h.  */
9583 <
9584 < #include <openbabel/babelconfig.h>
9585 < #include <openbabel/obconversion.h>
9586 < using namespace std;
9587 < using namespace OpenBabel;
9588 <
9589 < #ifdef FC_DUMMY_MAIN
9590 < #ifndef FC_DUMMY_MAIN_EQ_F77
9591 < #  ifdef __cplusplus
9592 <     extern "C"
9593 < #  endif
9594 <   int FC_DUMMY_MAIN() { return 1; }
9595 < #endif
9596 < #endif
9597 < int
9598 < main ()
9599 < {
9600 <
9601 < OBConversion Conv(&cin, &cout);
9602 <
9603 <
9604 <  ;
9605 <  return 0;
9606 < }
9607 < _ACEOF
9608 < rm -f conftest.$ac_objext conftest$ac_exeext
9609 < if { (ac_try="$ac_link"
9610 < case "(($ac_try" in
9611 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9612 <  *) ac_try_echo=$ac_try;;
9613 < esac
9614 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9615 <  (eval "$ac_link") 2>conftest.er1
9616 <  ac_status=$?
9617 <  grep -v '^ *+' conftest.er1 >conftest.err
9618 <  rm -f conftest.er1
9619 <  cat conftest.err >&5
9620 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9621 <  (exit $ac_status); } && {
9622 <         test -z "$ac_cxx_werror_flag" ||
9623 <         test ! -s conftest.err
9624 <       } && test -s conftest$ac_exeext &&
9625 <       $as_test_x conftest$ac_exeext; then
9626 <
9627 <                openbabel_lib_found="yes"
9628 <                { echo "$as_me:$LINENO: result: found" >&5
9629 < echo "${ECHO_T}found" >&6; }
9630 <
9631 < else
9632 <  echo "$as_me: failed program was:" >&5
9633 < sed 's/^/| /' conftest.$ac_ext >&5
9634 <
9635 <
9636 <                openbabel_lib_found="no"
9637 <                { echo "$as_me:$LINENO: result: not found" >&5
9638 < echo "${ECHO_T}not found" >&6; }
9639 <
9640 <
9641 < fi
9642 <
9643 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
9644 <      conftest$ac_exeext conftest.$ac_ext
9645 <        ac_ext=c
9646 < ac_cpp='$CPP $CPPFLAGS'
9647 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
9648 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
9649 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
9650 <
9651 <        LDFLAGS="$OPENBABEL_OLD_LDFLAGS"
9652 <        CPPFLAGS="$OPENBABEL_OLD_CPPFLAGS"
9653 <
9654 <        if test "$openbabel_lib_found" = "yes" -a "$openbabel_cv_openbabel_h" = "yes" -a "$openbabel_cv_obconversion_h" = "yes"; then
9655 <                USE_OPENBABEL=yes
9656 <                OPENBABEL_INC_DIR="${OPENBABEL_HOME}/include/openbabel-2.0"
9657 <                OPENBABEL_LIB_DIR="${OPENBABEL_HOME}/lib"
9658 <                OPENBABEL_LIB="-lopenbabel"
9659 <        else
9660 <                { echo "$as_me:$LINENO: checking openbabel in ${OPENBABEL_HOME}" >&5
9661 < echo $ECHO_N "checking openbabel in ${OPENBABEL_HOME}... $ECHO_C" >&6; }
9662 <                OPENBABEL_INC_DIR=
9663 <                OPENBABEL_LIB_DIR=
9664 <                OPENBABEL_LIB=
9665 <                USE_OPENBABEL=no
9666 <                { echo "$as_me:$LINENO: result: failed" >&5
9667 < echo "${ECHO_T}failed" >&6; }
9668 <                echo ""
9669 <                echo "*********************************************************"
9670 <                echo "* WARNING: Could not find a working openbabel-2.x       *"
9671 <                echo "* installation If you need OOPSE to be able to convert  *"
9672 <                echo "* xyz or pdb files you need to specify a valid          *"
9673 <                echo "* openbabel-2.x installation with --with-openbabel=DIR  *"
9674 <                echo "*                                                       *"
9675 <                echo "* OOPSE will still work without openbabel installed.    *"
9676 <                echo "*********************************************************"
9677 <                echo ""
9678 <        fi
9679 <
9680 <
9681 <
9682 <
9683 < fi
9684 < fi
9685 <
9686 <
9687 < # Checks for header files.
9688 < { echo "$as_me:$LINENO: checking for ANSI C header files" >&5
9689 < echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6; }
9690 < if test "${ac_cv_header_stdc+set}" = set; then
9691 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9692 < else
9693 <  cat >conftest.$ac_ext <<_ACEOF
9694 < /* confdefs.h.  */
9695 < _ACEOF
9696 < cat confdefs.h >>conftest.$ac_ext
9697 < cat >>conftest.$ac_ext <<_ACEOF
9698 < /* end confdefs.h.  */
9699 < #include <stdlib.h>
9700 < #include <stdarg.h>
9701 < #include <string.h>
9702 < #include <float.h>
9703 <
9704 < #ifdef FC_DUMMY_MAIN
9705 < #ifndef FC_DUMMY_MAIN_EQ_F77
9706 < #  ifdef __cplusplus
9707 <     extern "C"
9708 < #  endif
9709 <   int FC_DUMMY_MAIN() { return 1; }
9710 < #endif
9711 < #endif
9712 < int
9713 < main ()
9714 < {
9715 <
9716 <  ;
9717 <  return 0;
9718 < }
9719 < _ACEOF
9720 < rm -f conftest.$ac_objext
9721 < if { (ac_try="$ac_compile"
9722 < case "(($ac_try" in
9723 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9724 <  *) ac_try_echo=$ac_try;;
9725 < esac
9726 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9727 <  (eval "$ac_compile") 2>conftest.er1
9728 <  ac_status=$?
9729 <  grep -v '^ *+' conftest.er1 >conftest.err
9730 <  rm -f conftest.er1
9731 <  cat conftest.err >&5
9732 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9733 <  (exit $ac_status); } && {
9734 <         test -z "$ac_c_werror_flag" ||
9735 <         test ! -s conftest.err
9736 <       } && test -s conftest.$ac_objext; then
9737 <  ac_cv_header_stdc=yes
9738 < else
9739 <  echo "$as_me: failed program was:" >&5
9740 < sed 's/^/| /' conftest.$ac_ext >&5
9741 <
9742 <        ac_cv_header_stdc=no
9743 < fi
9744 <
9745 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9746 <
9747 < if test $ac_cv_header_stdc = yes; then
9748 <  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
9749 <  cat >conftest.$ac_ext <<_ACEOF
9750 < /* confdefs.h.  */
9751 < _ACEOF
9752 < cat confdefs.h >>conftest.$ac_ext
9753 < cat >>conftest.$ac_ext <<_ACEOF
9754 < /* end confdefs.h.  */
9755 < #include <string.h>
9756 <
9757 < _ACEOF
9758 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
9759 <  $EGREP "memchr" >/dev/null 2>&1; then
9760 <  :
9761 < else
9762 <  ac_cv_header_stdc=no
9763 < fi
9764 < rm -f conftest*
9765 <
9766 < fi
9767 <
9768 < if test $ac_cv_header_stdc = yes; then
9769 <  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
9770 <  cat >conftest.$ac_ext <<_ACEOF
9771 < /* confdefs.h.  */
9772 < _ACEOF
9773 < cat confdefs.h >>conftest.$ac_ext
9774 < cat >>conftest.$ac_ext <<_ACEOF
9775 < /* end confdefs.h.  */
9776 < #include <stdlib.h>
9777 <
9778 < _ACEOF
9779 < if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
9780 <  $EGREP "free" >/dev/null 2>&1; then
9781 <  :
9782 < else
9783 <  ac_cv_header_stdc=no
9784 < fi
9785 < rm -f conftest*
9786 <
9787 < fi
9788 <
9789 < if test $ac_cv_header_stdc = yes; then
9790 <  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
9791 <  if test "$cross_compiling" = yes; then
9792 <  :
9793 < else
9794 <  cat >conftest.$ac_ext <<_ACEOF
9795 < /* confdefs.h.  */
9796 < _ACEOF
9797 < cat confdefs.h >>conftest.$ac_ext
9798 < cat >>conftest.$ac_ext <<_ACEOF
9799 < /* end confdefs.h.  */
9800 < #include <ctype.h>
9801 < #include <stdlib.h>
9802 < #if ((' ' & 0x0FF) == 0x020)
9803 < # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
9804 < # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
9805 < #else
9806 < # define ISLOWER(c) \
9807 <                   (('a' <= (c) && (c) <= 'i') \
9808 <                     || ('j' <= (c) && (c) <= 'r') \
9809 <                     || ('s' <= (c) && (c) <= 'z'))
9810 < # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
9811 < #endif
9812 <
9813 < #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
9814 < int
9815 < main ()
9816 < {
9817 <  int i;
9818 <  for (i = 0; i < 256; i++)
9819 <    if (XOR (islower (i), ISLOWER (i))
9820 <        || toupper (i) != TOUPPER (i))
9821 <      return 2;
9822 <  return 0;
9823 < }
9824 < _ACEOF
9825 < rm -f conftest$ac_exeext
9826 < if { (ac_try="$ac_link"
9827 < case "(($ac_try" in
9828 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9829 <  *) ac_try_echo=$ac_try;;
9830 < esac
9831 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9832 <  (eval "$ac_link") 2>&5
9833 <  ac_status=$?
9834 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9835 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
9836 <  { (case "(($ac_try" in
9837 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9838 <  *) ac_try_echo=$ac_try;;
9839 < esac
9840 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9841 <  (eval "$ac_try") 2>&5
9842 <  ac_status=$?
9843 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9844 <  (exit $ac_status); }; }; then
9845 <  :
9846 < else
9847 <  echo "$as_me: program exited with status $ac_status" >&5
9848 < echo "$as_me: failed program was:" >&5
9849 < sed 's/^/| /' conftest.$ac_ext >&5
9850 <
9851 < ( exit $ac_status )
9852 < ac_cv_header_stdc=no
9853 < fi
9854 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
9855 < fi
9856 <
9857 <
9858 < fi
9859 < fi
9860 < { echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
9861 < echo "${ECHO_T}$ac_cv_header_stdc" >&6; }
9862 < if test $ac_cv_header_stdc = yes; then
9863 <
9864 < cat >>confdefs.h <<\_ACEOF
9865 < #define STDC_HEADERS 1
9866 < _ACEOF
9867 <
9868 < fi
9869 <
9870 <
9871 <
9872 <
9873 <
9874 <
9875 <
9876 <
9877 <
9878 <
9879 <
9880 <
9881 <
9882 <
9883 <
9884 <
9885 < 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
9886 < do
9887 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
9888 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9889 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
9890 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
9891 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
9892 <  echo $ECHO_N "(cached) $ECHO_C" >&6
9893 < fi
9894 < ac_res=`eval echo '${'$as_ac_Header'}'`
9895 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
9896 < echo "${ECHO_T}$ac_res" >&6; }
9897 < else
9898 <  # Is the header compilable?
9899 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
9900 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
9901 < cat >conftest.$ac_ext <<_ACEOF
9902 < /* confdefs.h.  */
9903 < _ACEOF
9904 < cat confdefs.h >>conftest.$ac_ext
9905 < cat >>conftest.$ac_ext <<_ACEOF
9906 < /* end confdefs.h.  */
9907 < $ac_includes_default
9908 < #include <$ac_header>
9909 < _ACEOF
9910 < rm -f conftest.$ac_objext
9911 < if { (ac_try="$ac_compile"
9912 < case "(($ac_try" in
9913 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9914 <  *) ac_try_echo=$ac_try;;
9915 < esac
9916 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9917 <  (eval "$ac_compile") 2>conftest.er1
9918 <  ac_status=$?
9919 <  grep -v '^ *+' conftest.er1 >conftest.err
9920 <  rm -f conftest.er1
9921 <  cat conftest.err >&5
9922 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9923 <  (exit $ac_status); } && {
9924 <         test -z "$ac_c_werror_flag" ||
9925 <         test ! -s conftest.err
9926 <       } && test -s conftest.$ac_objext; then
9927 <  ac_header_compiler=yes
9928 < else
9929 <  echo "$as_me: failed program was:" >&5
9930 < sed 's/^/| /' conftest.$ac_ext >&5
9931 <
9932 <        ac_header_compiler=no
9933 < fi
9934 <
9935 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
9936 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
9937 < echo "${ECHO_T}$ac_header_compiler" >&6; }
9938 <
9939 < # Is the header present?
9940 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
9941 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
9942 < cat >conftest.$ac_ext <<_ACEOF
9943 < /* confdefs.h.  */
9944 < _ACEOF
9945 < cat confdefs.h >>conftest.$ac_ext
9946 < cat >>conftest.$ac_ext <<_ACEOF
9947 < /* end confdefs.h.  */
9948 < #include <$ac_header>
9949 < _ACEOF
9950 < if { (ac_try="$ac_cpp conftest.$ac_ext"
9951 < case "(($ac_try" in
9952 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
9953 <  *) ac_try_echo=$ac_try;;
9954 < esac
9955 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
9956 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
9957 <  ac_status=$?
9958 <  grep -v '^ *+' conftest.er1 >conftest.err
9959 <  rm -f conftest.er1
9960 <  cat conftest.err >&5
9961 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
9962 <  (exit $ac_status); } >/dev/null && {
9963 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
9964 <         test ! -s conftest.err
9965 <       }; then
9966 <  ac_header_preproc=yes
9967 < else
9968 <  echo "$as_me: failed program was:" >&5
9969 < sed 's/^/| /' conftest.$ac_ext >&5
9970 <
9971 <  ac_header_preproc=no
9972 < fi
9973 <
9974 < rm -f conftest.err conftest.$ac_ext
9975 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
9976 < echo "${ECHO_T}$ac_header_preproc" >&6; }
9977 <
9978 < # So?  What about this header?
9979 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
9980 <  yes:no: )
9981 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
9982 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
9983 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
9984 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
9985 <    ac_header_preproc=yes
9986 <    ;;
9987 <  no:yes:* )
9988 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
9989 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
9990 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
9991 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
9992 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
9993 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
9994 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
9995 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
9996 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
9997 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
9998 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
9999 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10000 <    ( cat <<\_ASBOX
10001 < ## ------------------------------ ##
10002 < ## Report this to gezelter@nd.edu ##
10003 < ## ------------------------------ ##
10004 < _ASBOX
10005 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10006 <    ;;
10007 < esac
10008 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
10009 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10010 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10011 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10012 < else
10013 <  eval "$as_ac_Header=\$ac_header_preproc"
10014 < fi
10015 < ac_res=`eval echo '${'$as_ac_Header'}'`
10016 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10017 < echo "${ECHO_T}$ac_res" >&6; }
10018 <
10019 < fi
10020 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10021 <  cat >>confdefs.h <<_ACEOF
10022 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10023 < _ACEOF
10024 <
10025 < fi
10026 <
10027 < done
10028 <
10029 <
10030 < # Checks for typedefs, structures, and compiler characteristics.
10031 < { echo "$as_me:$LINENO: checking for stdbool.h that conforms to C99" >&5
10032 < echo $ECHO_N "checking for stdbool.h that conforms to C99... $ECHO_C" >&6; }
10033 < if test "${ac_cv_header_stdbool_h+set}" = set; then
10034 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10035 < else
10036 <  cat >conftest.$ac_ext <<_ACEOF
10037 < /* confdefs.h.  */
10038 < _ACEOF
10039 < cat confdefs.h >>conftest.$ac_ext
10040 < cat >>conftest.$ac_ext <<_ACEOF
10041 < /* end confdefs.h.  */
10042 <
10043 < #include <stdbool.h>
10044 < #ifndef bool
10045 < "error: bool is not defined"
10046 < #endif
10047 < #ifndef false
10048 < "error: false is not defined"
10049 < #endif
10050 < #if false
10051 < "error: false is not 0"
10052 < #endif
10053 < #ifndef true
10054 < "error: true is not defined"
10055 < #endif
10056 < #if true != 1
10057 < "error: true is not 1"
10058 < #endif
10059 < #ifndef __bool_true_false_are_defined
10060 < "error: __bool_true_false_are_defined is not defined"
10061 < #endif
10062 <
10063 <        struct s { _Bool s: 1; _Bool t; } s;
10064 <
10065 <        char a[true == 1 ? 1 : -1];
10066 <        char b[false == 0 ? 1 : -1];
10067 <        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
10068 <        char d[(bool) 0.5 == true ? 1 : -1];
10069 <        bool e = &s;
10070 <        char f[(_Bool) 0.0 == false ? 1 : -1];
10071 <        char g[true];
10072 <        char h[sizeof (_Bool)];
10073 <        char i[sizeof s.t];
10074 <        enum { j = false, k = true, l = false * true, m = true * 256 };
10075 <        _Bool n[m];
10076 <        char o[sizeof n == m * sizeof n[0] ? 1 : -1];
10077 <        char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
10078 < #       if defined __xlc__ || defined __GNUC__
10079 <         /* Catch a bug in IBM AIX xlc compiler version 6.0.0.0
10080 <            reported by James Lemley on 2005-10-05; see
10081 <            http://lists.gnu.org/archive/html/bug-coreutils/2005-10/msg00086.html
10082 <            This test is not quite right, since xlc is allowed to
10083 <            reject this program, as the initializer for xlcbug is
10084 <            not one of the forms that C requires support for.
10085 <            However, doing the test right would require a runtime
10086 <            test, and that would make cross-compilation harder.
10087 <            Let us hope that IBM fixes the xlc bug, and also adds
10088 <            support for this kind of constant expression.  In the
10089 <            meantime, this test will reject xlc, which is OK, since
10090 <            our stdbool.h substitute should suffice.  We also test
10091 <            this with GCC, where it should work, to detect more
10092 <            quickly whether someone messes up the test in the
10093 <            future.  */
10094 <         char digs[] = "0123456789";
10095 <         int xlcbug = 1 / (&(digs + 5)[-2 + (bool) 1] == &digs[4] ? 1 : -1);
10096 < #       endif
10097 <        /* Catch a bug in an HP-UX C compiler.  See
10098 <           http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
10099 <           http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
10100 <         */
10101 <        _Bool q = true;
10102 <        _Bool *pq = &q;
10103 <
10104 < #ifdef FC_DUMMY_MAIN
10105 < #ifndef FC_DUMMY_MAIN_EQ_F77
10106 < #  ifdef __cplusplus
10107 <     extern "C"
10108 < #  endif
10109 <   int FC_DUMMY_MAIN() { return 1; }
10110 < #endif
10111 < #endif
10112 < int
10113 < main ()
10114 < {
10115 <
10116 <        *pq |= q;
10117 <        *pq |= ! q;
10118 <        /* Refer to every declared value, to avoid compiler optimizations.  */
10119 <        return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
10120 <                + !m + !n + !o + !p + !q + !pq);
10121 <
10122 <  ;
10123 <  return 0;
10124 < }
10125 < _ACEOF
10126 < rm -f conftest.$ac_objext
10127 < if { (ac_try="$ac_compile"
10128 < case "(($ac_try" in
10129 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10130 <  *) ac_try_echo=$ac_try;;
10131 < esac
10132 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10133 <  (eval "$ac_compile") 2>conftest.er1
10134 <  ac_status=$?
10135 <  grep -v '^ *+' conftest.er1 >conftest.err
10136 <  rm -f conftest.er1
10137 <  cat conftest.err >&5
10138 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10139 <  (exit $ac_status); } && {
10140 <         test -z "$ac_c_werror_flag" ||
10141 <         test ! -s conftest.err
10142 <       } && test -s conftest.$ac_objext; then
10143 <  ac_cv_header_stdbool_h=yes
10144 < else
10145 <  echo "$as_me: failed program was:" >&5
10146 < sed 's/^/| /' conftest.$ac_ext >&5
10147 <
10148 <        ac_cv_header_stdbool_h=no
10149 < fi
10150 <
10151 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10152 < fi
10153 < { echo "$as_me:$LINENO: result: $ac_cv_header_stdbool_h" >&5
10154 < echo "${ECHO_T}$ac_cv_header_stdbool_h" >&6; }
10155 < { echo "$as_me:$LINENO: checking for _Bool" >&5
10156 < echo $ECHO_N "checking for _Bool... $ECHO_C" >&6; }
10157 < if test "${ac_cv_type__Bool+set}" = set; then
10158 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10159 < else
10160 <  cat >conftest.$ac_ext <<_ACEOF
10161 < /* confdefs.h.  */
10162 < _ACEOF
10163 < cat confdefs.h >>conftest.$ac_ext
10164 < cat >>conftest.$ac_ext <<_ACEOF
10165 < /* end confdefs.h.  */
10166 < $ac_includes_default
10167 < typedef _Bool ac__type_new_;
10168 < #ifdef FC_DUMMY_MAIN
10169 < #ifndef FC_DUMMY_MAIN_EQ_F77
10170 < #  ifdef __cplusplus
10171 <     extern "C"
10172 < #  endif
10173 <   int FC_DUMMY_MAIN() { return 1; }
10174 < #endif
10175 < #endif
10176 < int
10177 < main ()
10178 < {
10179 < if ((ac__type_new_ *) 0)
10180 <  return 0;
10181 < if (sizeof (ac__type_new_))
10182 <  return 0;
10183 <  ;
10184 <  return 0;
10185 < }
10186 < _ACEOF
10187 < rm -f conftest.$ac_objext
10188 < if { (ac_try="$ac_compile"
10189 < case "(($ac_try" in
10190 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10191 <  *) ac_try_echo=$ac_try;;
10192 < esac
10193 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10194 <  (eval "$ac_compile") 2>conftest.er1
10195 <  ac_status=$?
10196 <  grep -v '^ *+' conftest.er1 >conftest.err
10197 <  rm -f conftest.er1
10198 <  cat conftest.err >&5
10199 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10200 <  (exit $ac_status); } && {
10201 <         test -z "$ac_c_werror_flag" ||
10202 <         test ! -s conftest.err
10203 <       } && test -s conftest.$ac_objext; then
10204 <  ac_cv_type__Bool=yes
10205 < else
10206 <  echo "$as_me: failed program was:" >&5
10207 < sed 's/^/| /' conftest.$ac_ext >&5
10208 <
10209 <        ac_cv_type__Bool=no
10210 < fi
10211 <
10212 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10213 < fi
10214 < { echo "$as_me:$LINENO: result: $ac_cv_type__Bool" >&5
10215 < echo "${ECHO_T}$ac_cv_type__Bool" >&6; }
10216 < if test $ac_cv_type__Bool = yes; then
10217 <
10218 < cat >>confdefs.h <<_ACEOF
10219 < #define HAVE__BOOL 1
10220 < _ACEOF
10221 <
10222 <
10223 < fi
10224 <
10225 < if test $ac_cv_header_stdbool_h = yes; then
10226 <
10227 < cat >>confdefs.h <<\_ACEOF
10228 < #define HAVE_STDBOOL_H 1
10229 < _ACEOF
10230 <
10231 < fi
10232 <
10233 < { echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5
10234 < echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6; }
10235 < if test "${ac_cv_c_const+set}" = set; then
10236 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10237 < else
10238 <  cat >conftest.$ac_ext <<_ACEOF
10239 < /* confdefs.h.  */
10240 < _ACEOF
10241 < cat confdefs.h >>conftest.$ac_ext
10242 < cat >>conftest.$ac_ext <<_ACEOF
10243 < /* end confdefs.h.  */
10244 <
10245 < #ifdef FC_DUMMY_MAIN
10246 < #ifndef FC_DUMMY_MAIN_EQ_F77
10247 < #  ifdef __cplusplus
10248 <     extern "C"
10249 < #  endif
10250 <   int FC_DUMMY_MAIN() { return 1; }
10251 < #endif
10252 < #endif
10253 < int
10254 < main ()
10255 < {
10256 < /* FIXME: Include the comments suggested by Paul. */
10257 < #ifndef __cplusplus
10258 <  /* Ultrix mips cc rejects this.  */
10259 <  typedef int charset[2];
10260 <  const charset cs;
10261 <  /* SunOS 4.1.1 cc rejects this.  */
10262 <  char const *const *pcpcc;
10263 <  char **ppc;
10264 <  /* NEC SVR4.0.2 mips cc rejects this.  */
10265 <  struct point {int x, y;};
10266 <  static struct point const zero = {0,0};
10267 <  /* AIX XL C 1.02.0.0 rejects this.
10268 <     It does not let you subtract one const X* pointer from another in
10269 <     an arm of an if-expression whose if-part is not a constant
10270 <     expression */
10271 <  const char *g = "string";
10272 <  pcpcc = &g + (g ? g-g : 0);
10273 <  /* HPUX 7.0 cc rejects these. */
10274 <  ++pcpcc;
10275 <  ppc = (char**) pcpcc;
10276 <  pcpcc = (char const *const *) ppc;
10277 <  { /* SCO 3.2v4 cc rejects this.  */
10278 <    char *t;
10279 <    char const *s = 0 ? (char *) 0 : (char const *) 0;
10280 <
10281 <    *t++ = 0;
10282 <    if (s) return 0;
10283 <  }
10284 <  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
10285 <    int x[] = {25, 17};
10286 <    const int *foo = &x[0];
10287 <    ++foo;
10288 <  }
10289 <  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
10290 <    typedef const int *iptr;
10291 <    iptr p = 0;
10292 <    ++p;
10293 <  }
10294 <  { /* AIX XL C 1.02.0.0 rejects this saying
10295 <       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
10296 <    struct s { int j; const int *ap[3]; };
10297 <    struct s *b; b->j = 5;
10298 <  }
10299 <  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
10300 <    const int foo = 10;
10301 <    if (!foo) return 0;
10302 <  }
10303 <  return !cs[0] && !zero.x;
10304 < #endif
10305 <
10306 <  ;
10307 <  return 0;
10308 < }
10309 < _ACEOF
10310 < rm -f conftest.$ac_objext
10311 < if { (ac_try="$ac_compile"
10312 < case "(($ac_try" in
10313 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10314 <  *) ac_try_echo=$ac_try;;
10315 < esac
10316 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10317 <  (eval "$ac_compile") 2>conftest.er1
10318 <  ac_status=$?
10319 <  grep -v '^ *+' conftest.er1 >conftest.err
10320 <  rm -f conftest.er1
10321 <  cat conftest.err >&5
10322 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10323 <  (exit $ac_status); } && {
10324 <         test -z "$ac_c_werror_flag" ||
10325 <         test ! -s conftest.err
10326 <       } && test -s conftest.$ac_objext; then
10327 <  ac_cv_c_const=yes
10328 < else
10329 <  echo "$as_me: failed program was:" >&5
10330 < sed 's/^/| /' conftest.$ac_ext >&5
10331 <
10332 <        ac_cv_c_const=no
10333 < fi
10334 <
10335 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10336 < fi
10337 < { echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5
10338 < echo "${ECHO_T}$ac_cv_c_const" >&6; }
10339 < if test $ac_cv_c_const = no; then
10340 <
10341 < cat >>confdefs.h <<\_ACEOF
10342 < #define const
10343 < _ACEOF
10344 <
10345 < fi
10346 <
10347 < { echo "$as_me:$LINENO: checking for inline" >&5
10348 < echo $ECHO_N "checking for inline... $ECHO_C" >&6; }
10349 < if test "${ac_cv_c_inline+set}" = set; then
10350 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10351 < else
10352 <  ac_cv_c_inline=no
10353 < for ac_kw in inline __inline__ __inline; do
10354 <  cat >conftest.$ac_ext <<_ACEOF
10355 < /* confdefs.h.  */
10356 < _ACEOF
10357 < cat confdefs.h >>conftest.$ac_ext
10358 < cat >>conftest.$ac_ext <<_ACEOF
10359 < /* end confdefs.h.  */
10360 < #ifndef __cplusplus
10361 < typedef int foo_t;
10362 < static $ac_kw foo_t static_foo () {return 0; }
10363 < $ac_kw foo_t foo () {return 0; }
10364 < #endif
10365 <
10366 < _ACEOF
10367 < rm -f conftest.$ac_objext
10368 < if { (ac_try="$ac_compile"
10369 < case "(($ac_try" in
10370 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10371 <  *) ac_try_echo=$ac_try;;
10372 < esac
10373 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10374 <  (eval "$ac_compile") 2>conftest.er1
10375 <  ac_status=$?
10376 <  grep -v '^ *+' conftest.er1 >conftest.err
10377 <  rm -f conftest.er1
10378 <  cat conftest.err >&5
10379 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10380 <  (exit $ac_status); } && {
10381 <         test -z "$ac_c_werror_flag" ||
10382 <         test ! -s conftest.err
10383 <       } && test -s conftest.$ac_objext; then
10384 <  ac_cv_c_inline=$ac_kw
10385 < else
10386 <  echo "$as_me: failed program was:" >&5
10387 < sed 's/^/| /' conftest.$ac_ext >&5
10388 <
10389 <
10390 < fi
10391 <
10392 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10393 <  test "$ac_cv_c_inline" != no && break
10394 < done
10395 <
10396 < fi
10397 < { echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5
10398 < echo "${ECHO_T}$ac_cv_c_inline" >&6; }
10399 <
10400 <
10401 < case $ac_cv_c_inline in
10402 <  inline | yes) ;;
10403 <  *)
10404 <    case $ac_cv_c_inline in
10405 <      no) ac_val=;;
10406 <      *) ac_val=$ac_cv_c_inline;;
10407 <    esac
10408 <    cat >>confdefs.h <<_ACEOF
10409 < #ifndef __cplusplus
10410 < #define inline $ac_val
10411 < #endif
10412 < _ACEOF
10413 <    ;;
10414 < esac
10415 <
10416 < { echo "$as_me:$LINENO: checking for size_t" >&5
10417 < echo $ECHO_N "checking for size_t... $ECHO_C" >&6; }
10418 < if test "${ac_cv_type_size_t+set}" = set; then
10419 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10420 < else
10421 <  cat >conftest.$ac_ext <<_ACEOF
10422 < /* confdefs.h.  */
10423 < _ACEOF
10424 < cat confdefs.h >>conftest.$ac_ext
10425 < cat >>conftest.$ac_ext <<_ACEOF
10426 < /* end confdefs.h.  */
10427 < $ac_includes_default
10428 < typedef size_t ac__type_new_;
10429 < #ifdef FC_DUMMY_MAIN
10430 < #ifndef FC_DUMMY_MAIN_EQ_F77
10431 < #  ifdef __cplusplus
10432 <     extern "C"
10433 < #  endif
10434 <   int FC_DUMMY_MAIN() { return 1; }
10435 < #endif
10436 < #endif
10437 < int
10438 < main ()
10439 < {
10440 < if ((ac__type_new_ *) 0)
10441 <  return 0;
10442 < if (sizeof (ac__type_new_))
10443 <  return 0;
10444 <  ;
10445 <  return 0;
10446 < }
10447 < _ACEOF
10448 < rm -f conftest.$ac_objext
10449 < if { (ac_try="$ac_compile"
10450 < case "(($ac_try" in
10451 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10452 <  *) ac_try_echo=$ac_try;;
10453 < esac
10454 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10455 <  (eval "$ac_compile") 2>conftest.er1
10456 <  ac_status=$?
10457 <  grep -v '^ *+' conftest.er1 >conftest.err
10458 <  rm -f conftest.er1
10459 <  cat conftest.err >&5
10460 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10461 <  (exit $ac_status); } && {
10462 <         test -z "$ac_c_werror_flag" ||
10463 <         test ! -s conftest.err
10464 <       } && test -s conftest.$ac_objext; then
10465 <  ac_cv_type_size_t=yes
10466 < else
10467 <  echo "$as_me: failed program was:" >&5
10468 < sed 's/^/| /' conftest.$ac_ext >&5
10469 <
10470 <        ac_cv_type_size_t=no
10471 < fi
10472 <
10473 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10474 < fi
10475 < { echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5
10476 < echo "${ECHO_T}$ac_cv_type_size_t" >&6; }
10477 < if test $ac_cv_type_size_t = yes; then
10478 <  :
10479 < else
10480 <
10481 < cat >>confdefs.h <<_ACEOF
10482 < #define size_t unsigned int
10483 < _ACEOF
10484 <
10485 < fi
10486 <
10487 < { echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5
10488 < echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6; }
10489 < if test "${ac_cv_header_time+set}" = set; then
10490 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10491 < else
10492 <  cat >conftest.$ac_ext <<_ACEOF
10493 < /* confdefs.h.  */
10494 < _ACEOF
10495 < cat confdefs.h >>conftest.$ac_ext
10496 < cat >>conftest.$ac_ext <<_ACEOF
10497 < /* end confdefs.h.  */
10498 < #include <sys/types.h>
10499 < #include <sys/time.h>
10500 < #include <time.h>
10501 <
10502 < #ifdef FC_DUMMY_MAIN
10503 < #ifndef FC_DUMMY_MAIN_EQ_F77
10504 < #  ifdef __cplusplus
10505 <     extern "C"
10506 < #  endif
10507 <   int FC_DUMMY_MAIN() { return 1; }
10508 < #endif
10509 < #endif
10510 < int
10511 < main ()
10512 < {
10513 < if ((struct tm *) 0)
10514 < return 0;
10515 <  ;
10516 <  return 0;
10517 < }
10518 < _ACEOF
10519 < rm -f conftest.$ac_objext
10520 < if { (ac_try="$ac_compile"
10521 < case "(($ac_try" in
10522 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10523 <  *) ac_try_echo=$ac_try;;
10524 < esac
10525 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10526 <  (eval "$ac_compile") 2>conftest.er1
10527 <  ac_status=$?
10528 <  grep -v '^ *+' conftest.er1 >conftest.err
10529 <  rm -f conftest.er1
10530 <  cat conftest.err >&5
10531 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10532 <  (exit $ac_status); } && {
10533 <         test -z "$ac_c_werror_flag" ||
10534 <         test ! -s conftest.err
10535 <       } && test -s conftest.$ac_objext; then
10536 <  ac_cv_header_time=yes
10537 < else
10538 <  echo "$as_me: failed program was:" >&5
10539 < sed 's/^/| /' conftest.$ac_ext >&5
10540 <
10541 <        ac_cv_header_time=no
10542 < fi
10543 <
10544 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10545 < fi
10546 < { echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5
10547 < echo "${ECHO_T}$ac_cv_header_time" >&6; }
10548 < if test $ac_cv_header_time = yes; then
10549 <
10550 < cat >>confdefs.h <<\_ACEOF
10551 < #define TIME_WITH_SYS_TIME 1
10552 < _ACEOF
10553 <
10554 < fi
10555 <
10556 <
10557 < # Checks for library functions.
10558 <
10559 < for ac_header in stdlib.h
10560 < do
10561 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10562 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10563 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
10564 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10565 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10566 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10567 < fi
10568 < ac_res=`eval echo '${'$as_ac_Header'}'`
10569 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10570 < echo "${ECHO_T}$ac_res" >&6; }
10571 < else
10572 <  # Is the header compilable?
10573 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
10574 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
10575 < cat >conftest.$ac_ext <<_ACEOF
10576 < /* confdefs.h.  */
10577 < _ACEOF
10578 < cat confdefs.h >>conftest.$ac_ext
10579 < cat >>conftest.$ac_ext <<_ACEOF
10580 < /* end confdefs.h.  */
10581 < $ac_includes_default
10582 < #include <$ac_header>
10583 < _ACEOF
10584 < rm -f conftest.$ac_objext
10585 < if { (ac_try="$ac_compile"
10586 < case "(($ac_try" in
10587 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10588 <  *) ac_try_echo=$ac_try;;
10589 < esac
10590 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10591 <  (eval "$ac_compile") 2>conftest.er1
10592 <  ac_status=$?
10593 <  grep -v '^ *+' conftest.er1 >conftest.err
10594 <  rm -f conftest.er1
10595 <  cat conftest.err >&5
10596 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10597 <  (exit $ac_status); } && {
10598 <         test -z "$ac_c_werror_flag" ||
10599 <         test ! -s conftest.err
10600 <       } && test -s conftest.$ac_objext; then
10601 <  ac_header_compiler=yes
10602 < else
10603 <  echo "$as_me: failed program was:" >&5
10604 < sed 's/^/| /' conftest.$ac_ext >&5
10605 <
10606 <        ac_header_compiler=no
10607 < fi
10608 <
10609 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10610 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10611 < echo "${ECHO_T}$ac_header_compiler" >&6; }
10612 <
10613 < # Is the header present?
10614 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
10615 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
10616 < cat >conftest.$ac_ext <<_ACEOF
10617 < /* confdefs.h.  */
10618 < _ACEOF
10619 < cat confdefs.h >>conftest.$ac_ext
10620 < cat >>conftest.$ac_ext <<_ACEOF
10621 < /* end confdefs.h.  */
10622 < #include <$ac_header>
10623 < _ACEOF
10624 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10625 < case "(($ac_try" in
10626 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10627 <  *) ac_try_echo=$ac_try;;
10628 < esac
10629 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10630 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10631 <  ac_status=$?
10632 <  grep -v '^ *+' conftest.er1 >conftest.err
10633 <  rm -f conftest.er1
10634 <  cat conftest.err >&5
10635 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10636 <  (exit $ac_status); } >/dev/null && {
10637 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10638 <         test ! -s conftest.err
10639 <       }; then
10640 <  ac_header_preproc=yes
10641 < else
10642 <  echo "$as_me: failed program was:" >&5
10643 < sed 's/^/| /' conftest.$ac_ext >&5
10644 <
10645 <  ac_header_preproc=no
10646 < fi
10647 <
10648 < rm -f conftest.err conftest.$ac_ext
10649 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10650 < echo "${ECHO_T}$ac_header_preproc" >&6; }
10651 <
10652 < # So?  What about this header?
10653 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10654 <  yes:no: )
10655 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10656 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10657 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10658 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10659 <    ac_header_preproc=yes
10660 <    ;;
10661 <  no:yes:* )
10662 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10663 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10664 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10665 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10666 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10667 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10668 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10669 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10670 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10671 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10672 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10673 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10674 <    ( cat <<\_ASBOX
10675 < ## ------------------------------ ##
10676 < ## Report this to gezelter@nd.edu ##
10677 < ## ------------------------------ ##
10678 < _ASBOX
10679 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10680 <    ;;
10681 < esac
10682 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
10683 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10684 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10685 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10686 < else
10687 <  eval "$as_ac_Header=\$ac_header_preproc"
10688 < fi
10689 < ac_res=`eval echo '${'$as_ac_Header'}'`
10690 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10691 < echo "${ECHO_T}$ac_res" >&6; }
10692 <
10693 < fi
10694 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10695 <  cat >>confdefs.h <<_ACEOF
10696 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10697 < _ACEOF
10698 <
10699 < fi
10700 <
10701 < done
10702 <
10703 < { echo "$as_me:$LINENO: checking for GNU libc compatible malloc" >&5
10704 < echo $ECHO_N "checking for GNU libc compatible malloc... $ECHO_C" >&6; }
10705 < if test "${ac_cv_func_malloc_0_nonnull+set}" = set; then
10706 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10707 < else
10708 <  if test "$cross_compiling" = yes; then
10709 <  ac_cv_func_malloc_0_nonnull=no
10710 < else
10711 <  cat >conftest.$ac_ext <<_ACEOF
10712 < /* confdefs.h.  */
10713 < _ACEOF
10714 < cat confdefs.h >>conftest.$ac_ext
10715 < cat >>conftest.$ac_ext <<_ACEOF
10716 < /* end confdefs.h.  */
10717 < #if defined STDC_HEADERS || defined HAVE_STDLIB_H
10718 < # include <stdlib.h>
10719 < #else
10720 < char *malloc ();
10721 < #endif
10722 <
10723 < #ifdef FC_DUMMY_MAIN
10724 < #ifndef FC_DUMMY_MAIN_EQ_F77
10725 < #  ifdef __cplusplus
10726 <     extern "C"
10727 < #  endif
10728 <   int FC_DUMMY_MAIN() { return 1; }
10729 < #endif
10730 < #endif
10731 < int
10732 < main ()
10733 < {
10734 < return ! malloc (0);
10735 <  ;
10736 <  return 0;
10737 < }
10738 < _ACEOF
10739 < rm -f conftest$ac_exeext
10740 < if { (ac_try="$ac_link"
10741 < case "(($ac_try" in
10742 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10743 <  *) ac_try_echo=$ac_try;;
10744 < esac
10745 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10746 <  (eval "$ac_link") 2>&5
10747 <  ac_status=$?
10748 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10749 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10750 <  { (case "(($ac_try" in
10751 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10752 <  *) ac_try_echo=$ac_try;;
10753 < esac
10754 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10755 <  (eval "$ac_try") 2>&5
10756 <  ac_status=$?
10757 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10758 <  (exit $ac_status); }; }; then
10759 <  ac_cv_func_malloc_0_nonnull=yes
10760 < else
10761 <  echo "$as_me: program exited with status $ac_status" >&5
10762 < echo "$as_me: failed program was:" >&5
10763 < sed 's/^/| /' conftest.$ac_ext >&5
10764 <
10765 < ( exit $ac_status )
10766 < ac_cv_func_malloc_0_nonnull=no
10767 < fi
10768 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
10769 < fi
10770 <
10771 <
10772 < fi
10773 < { echo "$as_me:$LINENO: result: $ac_cv_func_malloc_0_nonnull" >&5
10774 < echo "${ECHO_T}$ac_cv_func_malloc_0_nonnull" >&6; }
10775 < if test $ac_cv_func_malloc_0_nonnull = yes; then
10776 <
10777 < cat >>confdefs.h <<\_ACEOF
10778 < #define HAVE_MALLOC 1
10779 < _ACEOF
10780 <
10781 < else
10782 <  cat >>confdefs.h <<\_ACEOF
10783 < #define HAVE_MALLOC 0
10784 < _ACEOF
10785 <
10786 <   case " $LIBOBJS " in
10787 <  *" malloc.$ac_objext "* ) ;;
10788 <  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
10789 < ;;
10790 < esac
10791 <
10792 <
10793 < cat >>confdefs.h <<\_ACEOF
10794 < #define malloc rpl_malloc
10795 < _ACEOF
10796 <
10797 < fi
10798 <
10799 <
10800 <
10801 <
10802 < for ac_header in stdlib.h
10803 < do
10804 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
10805 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10806 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
10807 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10808 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10809 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10810 < fi
10811 < ac_res=`eval echo '${'$as_ac_Header'}'`
10812 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10813 < echo "${ECHO_T}$ac_res" >&6; }
10814 < else
10815 <  # Is the header compilable?
10816 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
10817 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
10818 < cat >conftest.$ac_ext <<_ACEOF
10819 < /* confdefs.h.  */
10820 < _ACEOF
10821 < cat confdefs.h >>conftest.$ac_ext
10822 < cat >>conftest.$ac_ext <<_ACEOF
10823 < /* end confdefs.h.  */
10824 < $ac_includes_default
10825 < #include <$ac_header>
10826 < _ACEOF
10827 < rm -f conftest.$ac_objext
10828 < if { (ac_try="$ac_compile"
10829 < case "(($ac_try" in
10830 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10831 <  *) ac_try_echo=$ac_try;;
10832 < esac
10833 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10834 <  (eval "$ac_compile") 2>conftest.er1
10835 <  ac_status=$?
10836 <  grep -v '^ *+' conftest.er1 >conftest.err
10837 <  rm -f conftest.er1
10838 <  cat conftest.err >&5
10839 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10840 <  (exit $ac_status); } && {
10841 <         test -z "$ac_c_werror_flag" ||
10842 <         test ! -s conftest.err
10843 <       } && test -s conftest.$ac_objext; then
10844 <  ac_header_compiler=yes
10845 < else
10846 <  echo "$as_me: failed program was:" >&5
10847 < sed 's/^/| /' conftest.$ac_ext >&5
10848 <
10849 <        ac_header_compiler=no
10850 < fi
10851 <
10852 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
10853 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
10854 < echo "${ECHO_T}$ac_header_compiler" >&6; }
10855 <
10856 < # Is the header present?
10857 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
10858 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
10859 < cat >conftest.$ac_ext <<_ACEOF
10860 < /* confdefs.h.  */
10861 < _ACEOF
10862 < cat confdefs.h >>conftest.$ac_ext
10863 < cat >>conftest.$ac_ext <<_ACEOF
10864 < /* end confdefs.h.  */
10865 < #include <$ac_header>
10866 < _ACEOF
10867 < if { (ac_try="$ac_cpp conftest.$ac_ext"
10868 < case "(($ac_try" in
10869 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10870 <  *) ac_try_echo=$ac_try;;
10871 < esac
10872 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10873 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
10874 <  ac_status=$?
10875 <  grep -v '^ *+' conftest.er1 >conftest.err
10876 <  rm -f conftest.er1
10877 <  cat conftest.err >&5
10878 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10879 <  (exit $ac_status); } >/dev/null && {
10880 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
10881 <         test ! -s conftest.err
10882 <       }; then
10883 <  ac_header_preproc=yes
10884 < else
10885 <  echo "$as_me: failed program was:" >&5
10886 < sed 's/^/| /' conftest.$ac_ext >&5
10887 <
10888 <  ac_header_preproc=no
10889 < fi
10890 <
10891 < rm -f conftest.err conftest.$ac_ext
10892 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
10893 < echo "${ECHO_T}$ac_header_preproc" >&6; }
10894 <
10895 < # So?  What about this header?
10896 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
10897 <  yes:no: )
10898 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
10899 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
10900 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
10901 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
10902 <    ac_header_preproc=yes
10903 <    ;;
10904 <  no:yes:* )
10905 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
10906 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
10907 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
10908 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
10909 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
10910 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
10911 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
10912 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
10913 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
10914 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
10915 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
10916 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
10917 <    ( cat <<\_ASBOX
10918 < ## ------------------------------ ##
10919 < ## Report this to gezelter@nd.edu ##
10920 < ## ------------------------------ ##
10921 < _ASBOX
10922 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
10923 <    ;;
10924 < esac
10925 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
10926 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
10927 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
10928 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10929 < else
10930 <  eval "$as_ac_Header=\$ac_header_preproc"
10931 < fi
10932 < ac_res=`eval echo '${'$as_ac_Header'}'`
10933 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
10934 < echo "${ECHO_T}$ac_res" >&6; }
10935 <
10936 < fi
10937 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
10938 <  cat >>confdefs.h <<_ACEOF
10939 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
10940 < _ACEOF
10941 <
10942 < fi
10943 <
10944 < done
10945 <
10946 < { echo "$as_me:$LINENO: checking for GNU libc compatible realloc" >&5
10947 < echo $ECHO_N "checking for GNU libc compatible realloc... $ECHO_C" >&6; }
10948 < if test "${ac_cv_func_realloc_0_nonnull+set}" = set; then
10949 <  echo $ECHO_N "(cached) $ECHO_C" >&6
10950 < else
10951 <  if test "$cross_compiling" = yes; then
10952 <  ac_cv_func_realloc_0_nonnull=no
10953 < else
10954 <  cat >conftest.$ac_ext <<_ACEOF
10955 < /* confdefs.h.  */
10956 < _ACEOF
10957 < cat confdefs.h >>conftest.$ac_ext
10958 < cat >>conftest.$ac_ext <<_ACEOF
10959 < /* end confdefs.h.  */
10960 < #if defined STDC_HEADERS || defined HAVE_STDLIB_H
10961 < # include <stdlib.h>
10962 < #else
10963 < char *realloc ();
10964 < #endif
10965 <
10966 < #ifdef FC_DUMMY_MAIN
10967 < #ifndef FC_DUMMY_MAIN_EQ_F77
10968 < #  ifdef __cplusplus
10969 <     extern "C"
10970 < #  endif
10971 <   int FC_DUMMY_MAIN() { return 1; }
10972 < #endif
10973 < #endif
10974 < int
10975 < main ()
10976 < {
10977 < return ! realloc (0, 0);
10978 <  ;
10979 <  return 0;
10980 < }
10981 < _ACEOF
10982 < rm -f conftest$ac_exeext
10983 < if { (ac_try="$ac_link"
10984 < case "(($ac_try" in
10985 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10986 <  *) ac_try_echo=$ac_try;;
10987 < esac
10988 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10989 <  (eval "$ac_link") 2>&5
10990 <  ac_status=$?
10991 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
10992 <  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
10993 <  { (case "(($ac_try" in
10994 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
10995 <  *) ac_try_echo=$ac_try;;
10996 < esac
10997 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
10998 <  (eval "$ac_try") 2>&5
10999 <  ac_status=$?
11000 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11001 <  (exit $ac_status); }; }; then
11002 <  ac_cv_func_realloc_0_nonnull=yes
11003 < else
11004 <  echo "$as_me: program exited with status $ac_status" >&5
11005 < echo "$as_me: failed program was:" >&5
11006 < sed 's/^/| /' conftest.$ac_ext >&5
11007 <
11008 < ( exit $ac_status )
11009 < ac_cv_func_realloc_0_nonnull=no
11010 < fi
11011 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11012 < fi
11013 <
11014 <
11015 < fi
11016 < { echo "$as_me:$LINENO: result: $ac_cv_func_realloc_0_nonnull" >&5
11017 < echo "${ECHO_T}$ac_cv_func_realloc_0_nonnull" >&6; }
11018 < if test $ac_cv_func_realloc_0_nonnull = yes; then
11019 <
11020 < cat >>confdefs.h <<\_ACEOF
11021 < #define HAVE_REALLOC 1
11022 < _ACEOF
11023 <
11024 < else
11025 <  cat >>confdefs.h <<\_ACEOF
11026 < #define HAVE_REALLOC 0
11027 < _ACEOF
11028 <
11029 <   case " $LIBOBJS " in
11030 <  *" realloc.$ac_objext "* ) ;;
11031 <  *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
11032 < ;;
11033 < esac
11034 <
11035 <
11036 < cat >>confdefs.h <<\_ACEOF
11037 < #define realloc rpl_realloc
11038 < _ACEOF
11039 <
11040 < fi
11041 <
11042 <
11043 <
11044 <
11045 <
11046 < for ac_header in sys/select.h sys/socket.h
11047 < do
11048 < as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
11049 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11050 <  { echo "$as_me:$LINENO: checking for $ac_header" >&5
11051 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11052 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11053 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11054 < fi
11055 < ac_res=`eval echo '${'$as_ac_Header'}'`
11056 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11057 < echo "${ECHO_T}$ac_res" >&6; }
11058 < else
11059 <  # Is the header compilable?
11060 < { echo "$as_me:$LINENO: checking $ac_header usability" >&5
11061 < echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6; }
11062 < cat >conftest.$ac_ext <<_ACEOF
11063 < /* confdefs.h.  */
11064 < _ACEOF
11065 < cat confdefs.h >>conftest.$ac_ext
11066 < cat >>conftest.$ac_ext <<_ACEOF
11067 < /* end confdefs.h.  */
11068 < $ac_includes_default
11069 < #include <$ac_header>
11070 < _ACEOF
11071 < rm -f conftest.$ac_objext
11072 < if { (ac_try="$ac_compile"
11073 < case "(($ac_try" in
11074 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11075 <  *) ac_try_echo=$ac_try;;
11076 < esac
11077 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11078 <  (eval "$ac_compile") 2>conftest.er1
11079 <  ac_status=$?
11080 <  grep -v '^ *+' conftest.er1 >conftest.err
11081 <  rm -f conftest.er1
11082 <  cat conftest.err >&5
11083 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11084 <  (exit $ac_status); } && {
11085 <         test -z "$ac_c_werror_flag" ||
11086 <         test ! -s conftest.err
11087 <       } && test -s conftest.$ac_objext; then
11088 <  ac_header_compiler=yes
11089 < else
11090 <  echo "$as_me: failed program was:" >&5
11091 < sed 's/^/| /' conftest.$ac_ext >&5
11092 <
11093 <        ac_header_compiler=no
11094 < fi
11095 <
11096 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11097 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
11098 < echo "${ECHO_T}$ac_header_compiler" >&6; }
11099 <
11100 < # Is the header present?
11101 < { echo "$as_me:$LINENO: checking $ac_header presence" >&5
11102 < echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6; }
11103 < cat >conftest.$ac_ext <<_ACEOF
11104 < /* confdefs.h.  */
11105 < _ACEOF
11106 < cat confdefs.h >>conftest.$ac_ext
11107 < cat >>conftest.$ac_ext <<_ACEOF
11108 < /* end confdefs.h.  */
11109 < #include <$ac_header>
11110 < _ACEOF
11111 < if { (ac_try="$ac_cpp conftest.$ac_ext"
11112 < case "(($ac_try" in
11113 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11114 <  *) ac_try_echo=$ac_try;;
11115 < esac
11116 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11117 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
11118 <  ac_status=$?
11119 <  grep -v '^ *+' conftest.er1 >conftest.err
11120 <  rm -f conftest.er1
11121 <  cat conftest.err >&5
11122 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11123 <  (exit $ac_status); } >/dev/null && {
11124 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
11125 <         test ! -s conftest.err
11126 <       }; then
11127 <  ac_header_preproc=yes
11128 < else
11129 <  echo "$as_me: failed program was:" >&5
11130 < sed 's/^/| /' conftest.$ac_ext >&5
11131 <
11132 <  ac_header_preproc=no
11133 < fi
11134 <
11135 < rm -f conftest.err conftest.$ac_ext
11136 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
11137 < echo "${ECHO_T}$ac_header_preproc" >&6; }
11138 <
11139 < # So?  What about this header?
11140 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
11141 <  yes:no: )
11142 <    { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5
11143 < echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}
11144 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5
11145 < echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}
11146 <    ac_header_preproc=yes
11147 <    ;;
11148 <  no:yes:* )
11149 <    { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5
11150 < echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}
11151 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     check for missing prerequisite headers?" >&5
11152 < echo "$as_me: WARNING: $ac_header:     check for missing prerequisite headers?" >&2;}
11153 <    { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5
11154 < echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}
11155 <    { echo "$as_me:$LINENO: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&5
11156 < echo "$as_me: WARNING: $ac_header:     section \"Present But Cannot Be Compiled\"" >&2;}
11157 <    { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5
11158 < echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}
11159 <    { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5
11160 < echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}
11161 <    ( cat <<\_ASBOX
11162 < ## ------------------------------ ##
11163 < ## Report this to gezelter@nd.edu ##
11164 < ## ------------------------------ ##
11165 < _ASBOX
11166 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
11167 <    ;;
11168 < esac
11169 < { echo "$as_me:$LINENO: checking for $ac_header" >&5
11170 < echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6; }
11171 < if { as_var=$as_ac_Header; eval "test \"\${$as_var+set}\" = set"; }; then
11172 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11173 < else
11174 <  eval "$as_ac_Header=\$ac_header_preproc"
11175 < fi
11176 < ac_res=`eval echo '${'$as_ac_Header'}'`
11177 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11178 < echo "${ECHO_T}$ac_res" >&6; }
11179 <
11180 < fi
11181 < if test `eval echo '${'$as_ac_Header'}'` = yes; then
11182 <  cat >>confdefs.h <<_ACEOF
11183 < #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
11184 < _ACEOF
11185 <
11186 < fi
11187 <
11188 < done
11189 <
11190 < { echo "$as_me:$LINENO: checking types of arguments for select" >&5
11191 < echo $ECHO_N "checking types of arguments for select... $ECHO_C" >&6; }
11192 < if test "${ac_cv_func_select_args+set}" = set; then
11193 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11194 < else
11195 <  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
11196 < for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
11197 <  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
11198 <   cat >conftest.$ac_ext <<_ACEOF
11199 < /* confdefs.h.  */
11200 < _ACEOF
11201 < cat confdefs.h >>conftest.$ac_ext
11202 < cat >>conftest.$ac_ext <<_ACEOF
11203 < /* end confdefs.h.  */
11204 < $ac_includes_default
11205 < #ifdef HAVE_SYS_SELECT_H
11206 < # include <sys/select.h>
11207 < #endif
11208 < #ifdef HAVE_SYS_SOCKET_H
11209 < # include <sys/socket.h>
11210 < #endif
11211 <
11212 < #ifdef FC_DUMMY_MAIN
11213 < #ifndef FC_DUMMY_MAIN_EQ_F77
11214 < #  ifdef __cplusplus
11215 <     extern "C"
11216 < #  endif
11217 <   int FC_DUMMY_MAIN() { return 1; }
11218 < #endif
11219 < #endif
11220 < int
11221 < main ()
11222 < {
11223 < extern int select ($ac_arg1,
11224 <                                            $ac_arg234, $ac_arg234, $ac_arg234,
11225 <                                            $ac_arg5);
11226 <  ;
11227 <  return 0;
11228 < }
11229 < _ACEOF
11230 < rm -f conftest.$ac_objext
11231 < if { (ac_try="$ac_compile"
11232 < case "(($ac_try" in
11233 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11234 <  *) ac_try_echo=$ac_try;;
11235 < esac
11236 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11237 <  (eval "$ac_compile") 2>conftest.er1
11238 <  ac_status=$?
11239 <  grep -v '^ *+' conftest.er1 >conftest.err
11240 <  rm -f conftest.er1
11241 <  cat conftest.err >&5
11242 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11243 <  (exit $ac_status); } && {
11244 <         test -z "$ac_c_werror_flag" ||
11245 <         test ! -s conftest.err
11246 <       } && test -s conftest.$ac_objext; then
11247 <  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
11248 < else
11249 <  echo "$as_me: failed program was:" >&5
11250 < sed 's/^/| /' conftest.$ac_ext >&5
11251 <
11252 <
11253 < fi
11254 <
11255 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11256 <  done
11257 < done
11258 < done
11259 < # Provide a safe default value.
11260 < : ${ac_cv_func_select_args='int,int *,struct timeval *'}
11261 <
11262 < fi
11263 < { echo "$as_me:$LINENO: result: $ac_cv_func_select_args" >&5
11264 < echo "${ECHO_T}$ac_cv_func_select_args" >&6; }
11265 < ac_save_IFS=$IFS; IFS=','
11266 < set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
11267 < IFS=$ac_save_IFS
11268 < shift
11269 <
11270 < cat >>confdefs.h <<_ACEOF
11271 < #define SELECT_TYPE_ARG1 $1
11272 < _ACEOF
11273 <
11274 <
11275 < cat >>confdefs.h <<_ACEOF
11276 < #define SELECT_TYPE_ARG234 ($2)
11277 < _ACEOF
11278 <
11279 <
11280 < cat >>confdefs.h <<_ACEOF
11281 < #define SELECT_TYPE_ARG5 ($3)
11282 < _ACEOF
11283 <
11284 < rm -f conftest*
11285 <
11286 < { echo "$as_me:$LINENO: checking for working strtod" >&5
11287 < echo $ECHO_N "checking for working strtod... $ECHO_C" >&6; }
11288 < if test "${ac_cv_func_strtod+set}" = set; then
11289 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11290 < else
11291 <  if test "$cross_compiling" = yes; then
11292 <  ac_cv_func_strtod=no
11293 < else
11294 <  cat >conftest.$ac_ext <<_ACEOF
11295 < /* confdefs.h.  */
11296 < _ACEOF
11297 < cat confdefs.h >>conftest.$ac_ext
11298 < cat >>conftest.$ac_ext <<_ACEOF
11299 < /* end confdefs.h.  */
11300 <
11301 < $ac_includes_default
11302 < #ifndef strtod
11303 < double strtod ();
11304 < #endif
11305 < int
11306 < main()
11307 < {
11308 <  {
11309 <    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
11310 <    char *string = " +69";
11311 <    char *term;
11312 <    double value;
11313 <    value = strtod (string, &term);
11314 <    if (value != 69 || term != (string + 4))
11315 <      return 1;
11316 <  }
11317 <
11318 <  {
11319 <    /* Under Solaris 2.4, strtod returns the wrong value for the
11320 <       terminating character under some conditions.  */
11321 <    char *string = "NaN";
11322 <    char *term;
11323 <    strtod (string, &term);
11324 <    if (term != string && *(term - 1) == 0)
11325 <      return 1;
11326 <  }
11327 <  return 0;
11328 < }
11329 <
11330 < _ACEOF
11331 < rm -f conftest$ac_exeext
11332 < if { (ac_try="$ac_link"
11333 < case "(($ac_try" in
11334 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11335 <  *) ac_try_echo=$ac_try;;
11336 < esac
11337 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11338 <  (eval "$ac_link") 2>&5
11339 <  ac_status=$?
11340 <  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 "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11347 <  (eval "$ac_try") 2>&5
11348 <  ac_status=$?
11349 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11350 <  (exit $ac_status); }; }; then
11351 <  ac_cv_func_strtod=yes
11352 < else
11353 <  echo "$as_me: program exited with status $ac_status" >&5
11354 < echo "$as_me: failed program was:" >&5
11355 < sed 's/^/| /' conftest.$ac_ext >&5
11356 <
11357 < ( exit $ac_status )
11358 < ac_cv_func_strtod=no
11359 < fi
11360 < rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
11361 < fi
11362 <
11363 <
11364 < fi
11365 < { echo "$as_me:$LINENO: result: $ac_cv_func_strtod" >&5
11366 < echo "${ECHO_T}$ac_cv_func_strtod" >&6; }
11367 < if test $ac_cv_func_strtod = no; then
11368 <  case " $LIBOBJS " in
11369 <  *" strtod.$ac_objext "* ) ;;
11370 <  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
11371 < ;;
11372 < esac
11373 <
11374 < { echo "$as_me:$LINENO: checking for pow" >&5
11375 < echo $ECHO_N "checking for pow... $ECHO_C" >&6; }
11376 < if test "${ac_cv_func_pow+set}" = set; then
11377 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11378 < else
11379 <  cat >conftest.$ac_ext <<_ACEOF
11380 < /* confdefs.h.  */
11381 < _ACEOF
11382 < cat confdefs.h >>conftest.$ac_ext
11383 < cat >>conftest.$ac_ext <<_ACEOF
11384 < /* end confdefs.h.  */
11385 < /* Define pow to an innocuous variant, in case <limits.h> declares pow.
11386 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11387 < #define pow innocuous_pow
11388 <
11389 < /* System header to define __stub macros and hopefully few prototypes,
11390 <    which can conflict with char pow (); below.
11391 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11392 <    <limits.h> exists even on freestanding compilers.  */
11393 <
11394 < #ifdef __STDC__
11395 < # include <limits.h>
11396 < #else
11397 < # include <assert.h>
11398 < #endif
11399 <
11400 < #undef pow
11401 <
11402 < /* Override any GCC internal prototype to avoid an error.
11403 <   Use char because int might match the return type of a GCC
11404 <   builtin and then its argument prototype would still apply.  */
11405 < #ifdef __cplusplus
11406 < extern "C"
11407 < #endif
11408 < char pow ();
11409 < /* The GNU C library defines this for functions which it implements
11410 <    to always fail with ENOSYS.  Some functions are actually named
11411 <    something starting with __ and the normal name is an alias.  */
11412 < #if defined __stub_pow || defined __stub___pow
11413 < choke me
11414 < #endif
11415 <
11416 < #ifdef FC_DUMMY_MAIN
11417 < #ifndef FC_DUMMY_MAIN_EQ_F77
11418 < #  ifdef __cplusplus
11419 <     extern "C"
11420 < #  endif
11421 <   int FC_DUMMY_MAIN() { return 1; }
11422 < #endif
11423 < #endif
11424 < int
11425 < main ()
11426 < {
11427 < return pow ();
11428 <  ;
11429 <  return 0;
11430 < }
11431 < _ACEOF
11432 < rm -f conftest.$ac_objext conftest$ac_exeext
11433 < if { (ac_try="$ac_link"
11434 < case "(($ac_try" in
11435 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11436 <  *) ac_try_echo=$ac_try;;
11437 < esac
11438 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11439 <  (eval "$ac_link") 2>conftest.er1
11440 <  ac_status=$?
11441 <  grep -v '^ *+' conftest.er1 >conftest.err
11442 <  rm -f conftest.er1
11443 <  cat conftest.err >&5
11444 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11445 <  (exit $ac_status); } && {
11446 <         test -z "$ac_c_werror_flag" ||
11447 <         test ! -s conftest.err
11448 <       } && test -s conftest$ac_exeext &&
11449 <       $as_test_x conftest$ac_exeext; then
11450 <  ac_cv_func_pow=yes
11451 < else
11452 <  echo "$as_me: failed program was:" >&5
11453 < sed 's/^/| /' conftest.$ac_ext >&5
11454 <
11455 <        ac_cv_func_pow=no
11456 < fi
11457 <
11458 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11459 <      conftest$ac_exeext conftest.$ac_ext
11460 < fi
11461 < { echo "$as_me:$LINENO: result: $ac_cv_func_pow" >&5
11462 < echo "${ECHO_T}$ac_cv_func_pow" >&6; }
11463 <
11464 < if test $ac_cv_func_pow = no; then
11465 <  { echo "$as_me:$LINENO: checking for pow in -lm" >&5
11466 < echo $ECHO_N "checking for pow in -lm... $ECHO_C" >&6; }
11467 < if test "${ac_cv_lib_m_pow+set}" = set; then
11468 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11469 < else
11470 <  ac_check_lib_save_LIBS=$LIBS
11471 < LIBS="-lm  $LIBS"
11472 < cat >conftest.$ac_ext <<_ACEOF
11473 < /* confdefs.h.  */
11474 < _ACEOF
11475 < cat confdefs.h >>conftest.$ac_ext
11476 < cat >>conftest.$ac_ext <<_ACEOF
11477 < /* end confdefs.h.  */
11478 <
11479 < /* Override any GCC internal prototype to avoid an error.
11480 <   Use char because int might match the return type of a GCC
11481 <   builtin and then its argument prototype would still apply.  */
11482 < #ifdef __cplusplus
11483 < extern "C"
11484 < #endif
11485 < char pow ();
11486 < #ifdef FC_DUMMY_MAIN
11487 < #ifndef FC_DUMMY_MAIN_EQ_F77
11488 < #  ifdef __cplusplus
11489 <     extern "C"
11490 < #  endif
11491 <   int FC_DUMMY_MAIN() { return 1; }
11492 < #endif
11493 < #endif
11494 < int
11495 < main ()
11496 < {
11497 < return pow ();
11498 <  ;
11499 <  return 0;
11500 < }
11501 < _ACEOF
11502 < rm -f conftest.$ac_objext conftest$ac_exeext
11503 < if { (ac_try="$ac_link"
11504 < case "(($ac_try" in
11505 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11506 <  *) ac_try_echo=$ac_try;;
11507 < esac
11508 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11509 <  (eval "$ac_link") 2>conftest.er1
11510 <  ac_status=$?
11511 <  grep -v '^ *+' conftest.er1 >conftest.err
11512 <  rm -f conftest.er1
11513 <  cat conftest.err >&5
11514 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11515 <  (exit $ac_status); } && {
11516 <         test -z "$ac_c_werror_flag" ||
11517 <         test ! -s conftest.err
11518 <       } && test -s conftest$ac_exeext &&
11519 <       $as_test_x conftest$ac_exeext; then
11520 <  ac_cv_lib_m_pow=yes
11521 < else
11522 <  echo "$as_me: failed program was:" >&5
11523 < sed 's/^/| /' conftest.$ac_ext >&5
11524 <
11525 <        ac_cv_lib_m_pow=no
11526 < fi
11527 <
11528 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11529 <      conftest$ac_exeext conftest.$ac_ext
11530 < LIBS=$ac_check_lib_save_LIBS
11531 < fi
11532 < { echo "$as_me:$LINENO: result: $ac_cv_lib_m_pow" >&5
11533 < echo "${ECHO_T}$ac_cv_lib_m_pow" >&6; }
11534 < if test $ac_cv_lib_m_pow = yes; then
11535 <  POW_LIB=-lm
11536 < else
11537 <  { echo "$as_me:$LINENO: WARNING: cannot find library containing definition of pow" >&5
11538 < echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
11539 < fi
11540 <
11541 < fi
11542 <
11543 < fi
11544 <
11545 <
11546 <
11547 <
11548 <
11549 <
11550 <
11551 <
11552 <
11553 <
11554 <
11555 <
11556 <
11557 <
11558 <
11559 <
11560 <
11561 <
11562 <
11563 <
11564 <
11565 <
11566 < 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
11567 < do
11568 < as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`
11569 < { echo "$as_me:$LINENO: checking for $ac_func" >&5
11570 < echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6; }
11571 < if { as_var=$as_ac_var; eval "test \"\${$as_var+set}\" = set"; }; then
11572 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11573 < else
11574 <  cat >conftest.$ac_ext <<_ACEOF
11575 < /* confdefs.h.  */
11576 < _ACEOF
11577 < cat confdefs.h >>conftest.$ac_ext
11578 < cat >>conftest.$ac_ext <<_ACEOF
11579 < /* end confdefs.h.  */
11580 < /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.
11581 <   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
11582 < #define $ac_func innocuous_$ac_func
11583 <
11584 < /* System header to define __stub macros and hopefully few prototypes,
11585 <    which can conflict with char $ac_func (); below.
11586 <    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
11587 <    <limits.h> exists even on freestanding compilers.  */
11588 <
11589 < #ifdef __STDC__
11590 < # include <limits.h>
11591 < #else
11592 < # include <assert.h>
11593 < #endif
11594 <
11595 < #undef $ac_func
11596 <
11597 < /* Override any GCC internal prototype to avoid an error.
11598 <   Use char because int might match the return type of a GCC
11599 <   builtin and then its argument prototype would still apply.  */
11600 < #ifdef __cplusplus
11601 < extern "C"
11602 < #endif
11603 < char $ac_func ();
11604 < /* The GNU C library defines this for functions which it implements
11605 <    to always fail with ENOSYS.  Some functions are actually named
11606 <    something starting with __ and the normal name is an alias.  */
11607 < #if defined __stub_$ac_func || defined __stub___$ac_func
11608 < choke me
11609 < #endif
11610 <
11611 < #ifdef FC_DUMMY_MAIN
11612 < #ifndef FC_DUMMY_MAIN_EQ_F77
11613 < #  ifdef __cplusplus
11614 <     extern "C"
11615 < #  endif
11616 <   int FC_DUMMY_MAIN() { return 1; }
11617 < #endif
11618 < #endif
11619 < int
11620 < main ()
11621 < {
11622 < return $ac_func ();
11623 <  ;
11624 <  return 0;
11625 < }
11626 < _ACEOF
11627 < rm -f conftest.$ac_objext conftest$ac_exeext
11628 < if { (ac_try="$ac_link"
11629 < case "(($ac_try" in
11630 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11631 <  *) ac_try_echo=$ac_try;;
11632 < esac
11633 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11634 <  (eval "$ac_link") 2>conftest.er1
11635 <  ac_status=$?
11636 <  grep -v '^ *+' conftest.er1 >conftest.err
11637 <  rm -f conftest.er1
11638 <  cat conftest.err >&5
11639 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11640 <  (exit $ac_status); } && {
11641 <         test -z "$ac_c_werror_flag" ||
11642 <         test ! -s conftest.err
11643 <       } && test -s conftest$ac_exeext &&
11644 <       $as_test_x conftest$ac_exeext; then
11645 <  eval "$as_ac_var=yes"
11646 < else
11647 <  echo "$as_me: failed program was:" >&5
11648 < sed 's/^/| /' conftest.$ac_ext >&5
11649 <
11650 <        eval "$as_ac_var=no"
11651 < fi
11652 <
11653 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
11654 <      conftest$ac_exeext conftest.$ac_ext
11655 < fi
11656 < ac_res=`eval echo '${'$as_ac_var'}'`
11657 <               { echo "$as_me:$LINENO: result: $ac_res" >&5
11658 < echo "${ECHO_T}$ac_res" >&6; }
11659 < if test `eval echo '${'$as_ac_var'}'` = yes; then
11660 <  cat >>confdefs.h <<_ACEOF
11661 < #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1
11662 < _ACEOF
11663 <
11664 < fi
11665 < done
11666 <
11667 <
11668 < # special check for _system_configuration because AIX <4.3.2 do not
11669 < # contain the `physmem' member.
11670 < { echo "$as_me:$LINENO: checking for external symbol _system_configuration" >&5
11671 < echo $ECHO_N "checking for external symbol _system_configuration... $ECHO_C" >&6; }
11672 < cat >conftest.$ac_ext <<_ACEOF
11673 < /* confdefs.h.  */
11674 < _ACEOF
11675 < cat confdefs.h >>conftest.$ac_ext
11676 < cat >>conftest.$ac_ext <<_ACEOF
11677 < /* end confdefs.h.  */
11678 < #include <sys/systemcfg.h>
11679 < #ifdef FC_DUMMY_MAIN
11680 < #ifndef FC_DUMMY_MAIN_EQ_F77
11681 < #  ifdef __cplusplus
11682 <     extern "C"
11683 < #  endif
11684 <   int FC_DUMMY_MAIN() { return 1; }
11685 < #endif
11686 < #endif
11687 < int
11688 < main ()
11689 < {
11690 < double x = _system_configuration.physmem;
11691 <  ;
11692 <  return 0;
11693 < }
11694 < _ACEOF
11695 < rm -f conftest.$ac_objext
11696 < if { (ac_try="$ac_compile"
11697 < case "(($ac_try" in
11698 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
11699 <  *) ac_try_echo=$ac_try;;
11700 < esac
11701 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
11702 <  (eval "$ac_compile") 2>conftest.er1
11703 <  ac_status=$?
11704 <  grep -v '^ *+' conftest.er1 >conftest.err
11705 <  rm -f conftest.er1
11706 <  cat conftest.err >&5
11707 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11708 <  (exit $ac_status); } && {
11709 <         test -z "$ac_c_werror_flag" ||
11710 <         test ! -s conftest.err
11711 <       } && test -s conftest.$ac_objext; then
11712 <  { echo "$as_me:$LINENO: result: yes" >&5
11713 < echo "${ECHO_T}yes" >&6; }
11714 <
11715 < cat >>confdefs.h <<\_ACEOF
11716 < #define HAVE__SYSTEM_CONFIGURATION 1
11717 < _ACEOF
11718 <
11719 < else
11720 <  echo "$as_me: failed program was:" >&5
11721 < sed 's/^/| /' conftest.$ac_ext >&5
11722 <
11723 <        { echo "$as_me:$LINENO: result: no" >&5
11724 < echo "${ECHO_T}no" >&6; }
11725 < fi
11726 <
11727 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
11728 <
11729 <
11730 < case $debug in
11731 <  1)
11732 <     ;;
11733 <  *)
11734 <
11735 <
11736 <
11737 <
11738 <
11739 < # Try to determine "good" native compiler flags if none specified on command
11740 < # line
11741 <
11742 < if test "$ac_test_FFLAGS" != "set"; then
11743 <  FCFLAGS=""
11744 <  case "${host_cpu}-${host_os}" in
11745 <
11746 <  *linux*) if test "$FC" = ifc -o "$FC" = ifort; then
11747 <                    FCFLAGS="-O2"
11748 <                fi;;
11749 <   rs6000*-aix*)  if test "$FC" = xlf90 -o "$FC" = f90 -o "$FC" = xlf95; then
11750 <                    FCFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
11751 <                fi;;
11752 <   powerpc*-aix*)
11753 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11754 <                FCFLAGS="-O3 -qarch=ppc -qansialias -w"
11755 <                echo "*******************************************************"
11756 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11757 <                echo "*  recommended that you use                           *"
11758 <                echo "*                                                     *"
11759 <                echo "*   FCFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11760 <                echo "*                                 ^^^                 *"
11761 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11762 <                echo "*  PowerPC CPU you have.   For more info, man xlf.    *"
11763 <                echo "*******************************************************"
11764 <        fi;;
11765 <   *darwin*)
11766 <        if test "$FC" = f90 -o "$FC" = xlf90 -o "$FC" = xlf95; then
11767 <                FCFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto"
11768 <        fi
11769 <        if test "$FC" = ifort; then
11770 <                FCFLAGS="-O2"
11771 <        fi
11772 <        if test "$FC" = gfortran; then
11773 <                FCFLAGS="-Os"
11774 <        fi;;
11775 <  esac
11776 <
11777 <  if test -z "$FCFLAGS"; then
11778 <        echo ""
11779 <        echo "*********************************************************"
11780 <        echo "* WARNING: Don't know the best FCFLAGS for this system  *"
11781 <        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11782 <        echo "* (otherwise, a default of FCFLAGS=-O will be used)     *"
11783 <        echo "*********************************************************"
11784 <        echo ""
11785 <        FCFLAGS="-O"
11786 <  fi
11787 <
11788 <
11789 < { echo "$as_me:$LINENO: checking whether ${FC} accepts ${FCFLAGS}" >&5
11790 < echo $ECHO_N "checking whether ${FC} accepts ${FCFLAGS}... $ECHO_C" >&6; }
11791 < if test "${ac_guessed_f90flags+set}" = set; then
11792 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11793 < else
11794 <
11795 <
11796 < ac_ext=${ac_fc_srcext-f}
11797 < ac_compile='$FC -c $FCFLAGS $ac_fcflags_srcext conftest.$ac_ext >&5'
11798 < ac_link='$FC -o conftest$ac_exeext $FCFLAGS $LDFLAGS $ac_fcflags_srcext conftest.$ac_ext $LIBS >&5'
11799 < ac_compiler_gnu=$ac_cv_fc_compiler_gnu
11800 <
11801 < echo 'program main' > conftest.$ac_ext
11802 < echo 'end program main' >> conftest.$ac_ext
11803 < ac_compile='${FC} -c ${FCFLAGS} $FCFLAGS $FCFLAGS_SRCEXT conftest.$ac_ext 1>&5'
11804 < if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11805 <  (eval $ac_compile) 2>&5
11806 <  ac_status=$?
11807 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11808 <  (exit $ac_status); }; then
11809 <        ac_guessed_f90flags=yes
11810 < else
11811 <        ac_guessed_f90flags=no
11812 < fi
11813 < rm -f conftest*
11814 < ac_ext=c
11815 < ac_cpp='$CPP $CPPFLAGS'
11816 < ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
11817 < ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
11818 < ac_compiler_gnu=$ac_cv_c_compiler_gnu
11819 <
11820 <
11821 < fi
11822 < { echo "$as_me:$LINENO: result: $ac_guessed_f90flags" >&5
11823 < echo "${ECHO_T}$ac_guessed_f90flags" >&6; }
11824 < if test "$ac_guessed_f90flags" = yes; then
11825 <        :
11826 <
11827 < else
11828 <        :
11829 <
11830 <        echo ""
11831 <        echo "**********************************************************"
11832 <        echo "* WARNING: The guessed FCFLAGS don't seem to work with  *"
11833 <        echo "* your compiler.                                        *"
11834 <        echo "* Use  make FCFLAGS=..., or edit the top level Makefile *"
11835 <        echo "*********************************************************"
11836 <        echo ""
11837 <        FCFLAGS=""
11838 <
11839 < fi
11840 <
11841 <
11842 < fi
11843 <
11844 <
11845 <
11846 <
11847 <
11848 <
11849 <
11850 < { echo "$as_me:$LINENO: checking whether we are *really* using GNU cc" >&5
11851 < echo $ECHO_N "checking whether we are *really* using GNU cc... $ECHO_C" >&6; }
11852 < if test "${ac_cv_prog_really_gcc+set}" = set; then
11853 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11854 < else
11855 <
11856 < cat > conftest.c <<EOF
11857 < #ifdef __GNUC__
11858 <  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
11859 <     no;
11860 <  #else
11861 <     yes;
11862 <  #endif
11863 < #endif
11864 < EOF
11865 < if { ac_try='${CC-cc} -E conftest.c'
11866 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11867 <  (eval $ac_try) 2>&5
11868 <  ac_status=$?
11869 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
11870 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
11871 <  ac_cv_prog_really_gcc=yes
11872 < else
11873 <  ac_cv_prog_really_gcc=no
11874 < fi
11875 <
11876 < fi
11877 < { echo "$as_me:$LINENO: result: $ac_cv_prog_really_gcc" >&5
11878 < echo "${ECHO_T}$ac_cv_prog_really_gcc" >&6; }
11879 < if test "$ac_cv_prog_really_gcc" = yes; then
11880 <        :
11881 <
11882 < else
11883 <        :
11884 <
11885 < fi
11886 <
11887 <
11888 < # Try to determine "good" native compiler flags if none specified on command
11889 < # line
11890 < if test "$ac_test_CFLAGS" != "set"; then
11891 <  CFLAGS=""
11892 <  case "${host_cpu}-${host_os}" in
11893 <
11894 <  *linux*) if test "$CC" = icc; then
11895 <                    CFLAGS="-O2"
11896 <                fi;;
11897 <  sparc-solaris2*) if test "$CC" = cc; then
11898 <                    CFLAGS="-O -dalign"
11899 <                 fi;;
11900 <
11901 <  alpha*-osf*)  if test "$CC" = cc; then
11902 <                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
11903 <                fi;;
11904 <
11905 <  hppa*-hpux*)  if test "$CC" = cc; then
11906 <                    CFLAGS="-Ae +O3 +Oall"
11907 <                fi;;
11908 <
11909 <   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
11910 <                    CFLAGS="-O3 -qtune=auto -qansialias -w"
11911 <                fi;;
11912 <   powerpc*-aix*)
11913 <        if test "$CC" = cc -o "$CC" = xlc; then
11914 <                CFLAGS="-O3 -qtune=auto -qansialias -w"
11915 <                echo "*******************************************************"
11916 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
11917 <                echo "*  recommended that you use                           *"
11918 <                echo "*                                                     *"
11919 <                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
11920 <                echo "*                                 ^^^                 *"
11921 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
11922 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
11923 <                echo "*******************************************************"
11924 <        fi;;
11925 <   *darwin*)
11926 <        if test "$CC" = xlc; then
11927 <                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
11928 <        fi
11929 <        if test "$CC" = icc; then
11930 <                CFLAGS="-O2"
11931 <        fi
11932 <        if test $ac_cv_prog_really_gcc = yes; then
11933 <                CFLAGS="-Os"
11934 <        fi;;
11935 <  esac
11936 <
11937 <  # use default flags for gcc on all systems
11938 <  if test $ac_cv_prog_really_gcc = yes -a -z "$CFLAGS"; then
11939 <     CFLAGS="-O2"
11940 <  fi
11941 <
11942 <  if test -z "$CFLAGS"; then
11943 <        echo ""
11944 <        echo "********************************************************"
11945 <        echo "* WARNING: Don't know the best CFLAGS for this system  *"
11946 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
11947 <        echo "* (otherwise, a default of CFLAGS=-O will be used)     *"
11948 <        echo "********************************************************"
11949 <        echo ""
11950 <        CFLAGS="-O"
11951 <  fi
11952 <
11953 <
11954 <
11955 < { echo "$as_me:$LINENO: checking whether ${CC} accepts ${CFLAGS}" >&5
11956 < echo $ECHO_N "checking whether ${CC} accepts ${CFLAGS}... $ECHO_C" >&6; }
11957 < if test "${ac_guessed_cflags+set}" = set; then
11958 <  echo $ECHO_N "(cached) $ECHO_C" >&6
11959 < else
11960 <  echo 'void f(){}' > conftest.c
11961 < if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
11962 <        ac_guessed_cflags=yes
11963 < else
11964 <        ac_guessed_cflags=no
11965 < fi
11966 < rm -f conftest*
11967 <
11968 < fi
11969 < { echo "$as_me:$LINENO: result: $ac_guessed_cflags" >&5
11970 < echo "${ECHO_T}$ac_guessed_cflags" >&6; }
11971 < if test "$ac_guessed_cflags" = yes; then
11972 <        :
11973 <
11974 < else
11975 <        :
11976 <
11977 <        echo ""
11978 <        echo "********************************************************"
11979 <        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
11980 <        echo "* your compiler.                                       *"
11981 <        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
11982 <        echo "********************************************************"
11983 <        echo ""
11984 <        CFLAGS=""
11985 <
11986 < fi
11987 <
11988 <
11989 < fi
11990 <
11991 <
11992 <
11993 <
11994 <
11995 <
11996 <
11997 < { echo "$as_me:$LINENO: checking whether we are *really* using GNU c++" >&5
11998 < echo $ECHO_N "checking whether we are *really* using GNU c++... $ECHO_C" >&6; }
11999 < if test "${ac_cv_prog_really_gxx+set}" = set; then
12000 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12001 < else
12002 <
12003 < cat > conftest.cpp <<EOF
12004 < #ifdef __GNUC__
12005 <  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
12006 <     no;
12007 <  #else
12008 <     yes;
12009 <  #endif
12010 < #endif
12011 < EOF
12012 < if { ac_try='${CXX-c++} -E conftest.cpp'
12013 <  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12014 <  (eval $ac_try) 2>&5
12015 <  ac_status=$?
12016 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12017 <  (exit $ac_status); }; } | egrep yes >/dev/null 2>&1; then
12018 <  ac_cv_prog_really_gxx=yes
12019 < else
12020 <  ac_cv_prog_really_gxx=no
12021 < fi
12022 <
12023 < fi
12024 < { echo "$as_me:$LINENO: result: $ac_cv_prog_really_gxx" >&5
12025 < echo "${ECHO_T}$ac_cv_prog_really_gxx" >&6; }
12026 < if test "$ac_cv_prog_really_gxx" = yes; then
12027 <        :
12028 <
12029 < else
12030 <        :
12031 <
12032 < fi
12033 <
12034 <
12035 < # Try to determine "good" native compiler flags if none specified on command
12036 < # line
12037 < if test "$ac_test_CXXFLAGS" != "set"; then
12038 <  CXXFLAGS=""
12039 <  case "${host_cpu}-${host_os}" in
12040 <
12041 <  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
12042 <                    CXXFLAGS="-O2"
12043 <                fi;;
12044 <  sparc-solaris2*) if test "$CXX" = CC; then
12045 <                    CXXFLAGS="-features=extensions -O -dalign"
12046 <                 fi;;
12047 <   rs6000*-aix*)  if test "$CXX" = xlC; then
12048 <                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
12049 <                fi;;
12050 <   powerpc*-aix*)
12051 <        if test "$CXX" = xlC; then
12052 <                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
12053 <                echo "*******************************************************"
12054 <                echo "*  You have AIX on an unknown powerpc system.  It is  *"
12055 <                echo "*  recommended that you use                           *"
12056 <                echo "*                                                     *"
12057 <                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
12058 <                echo "*                                 ^^^                 *"
12059 <                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
12060 <                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
12061 <                echo "*******************************************************"
12062 <        fi;;
12063 <   *darwin*)
12064 <        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
12065 <                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
12066 <        fi
12067 <        if test "$CXX" = icpc; then
12068 <                CXXFLAGS="-O2"
12069 <        fi
12070 <        if test $ac_cv_prog_really_gxx = yes; then
12071 <                CXXFLAGS="-Os"
12072 <        fi;;
12073 <  esac
12074 <
12075 <  # use default flags for gcc on all systems
12076 <  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
12077 <     CXXFLAGS="-O2"
12078 <  fi
12079 <
12080 <  if test -z "$CXXFLAGS"; then
12081 <        echo ""
12082 <        echo "**********************************************************"
12083 <        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
12084 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12085 <        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
12086 <        echo "**********************************************************"
12087 <        echo ""
12088 <        CXXFLAGS="-O"
12089 <  fi
12090 <
12091 <
12092 <
12093 < { echo "$as_me:$LINENO: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
12094 < echo $ECHO_N "checking whether ${CXX} accepts ${CXXFLAGS}... $ECHO_C" >&6; }
12095 < if test "${ac_guessed_cxxflags+set}" = set; then
12096 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12097 < else
12098 <  echo 'void f(){}' > conftest.cpp
12099 < if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
12100 <        ac_guessed_cxxflags=yes
12101 < else
12102 <        ac_guessed_cxxflags=no
12103 < fi
12104 < rm -f conftest*
12105 <
12106 < fi
12107 < { echo "$as_me:$LINENO: result: $ac_guessed_cxxflags" >&5
12108 < echo "${ECHO_T}$ac_guessed_cxxflags" >&6; }
12109 < if test "$ac_guessed_cxxflags" = yes; then
12110 <        :
12111 <
12112 < else
12113 <        :
12114 <
12115 <        echo ""
12116 <        echo "**********************************************************"
12117 <        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
12118 <        echo "* your compiler.                                         *"
12119 <        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
12120 <        echo "**********************************************************"
12121 <        echo ""
12122 <        CXXFLAGS=""
12123 <
12124 < fi
12125 <
12126 <
12127 < fi
12128 <
12129 <     ;;
12130 < esac
12131 <
12132 <
12133 < acx_cgal_found=no
12134 <
12135 < # Check whether --with-cgalmakefile was given.
12136 < if test "${with_cgalmakefile+set}" = set; then
12137 <  withval=$with_cgalmakefile;
12138 < fi
12139 <
12140 < case $with_cgalmakefile in
12141 <        yes | "") ;;
12142 <        no) acx_cgal_found=disable ;;
12143 <        -* | */* | *.a | *.so | *.so.* | *.o) CGAL_MAKEFILE="$with_cgalmakefile" ;;
12144 <        *) CGAL_MAKEFILE="$with_cgalmakefile" ;;
12145 < esac
12146 <
12147 < if test "$acx_cgal_found" == no; then
12148 <    { echo "$as_me:$LINENO: checking CGAL_MAKEFILE" >&5
12149 < echo $ECHO_N "checking CGAL_MAKEFILE... $ECHO_C" >&6; }
12150 <
12151 <    if test \! -z "$CGAL_MAKEFILE"; then
12152 <
12153 <        if test -e "$CGAL_MAKEFILE"; then
12154 <            tname=`mktemp /tmp/cgal_makefile_dsrXXXXXX`
12155 <
12156 < cat > $tname << _ACEOF
12157 < include $CGAL_MAKEFILE
12158 <
12159 < cppflags:
12160 <        @echo \$(CGAL_CXXFLAGS)
12161 <
12162 < cxxflags:
12163 <        @echo
12164 < ldflags:
12165 <        @echo \$(CGAL_LDFLAGS)
12166 < _ACEOF
12167 <            CGAL_CPPFLAGS="`make -s -f $tname cppflags`"
12168 <            CGAL_CXXFLAGS="`make -s -f $tname cxxflags`"
12169 <            CGAL_LDFLAGST="`make -s -f $tname ldflags`"
12170 <            for i in $CGAL_LDFLAGST; do
12171 <                if test `echo $i| grep -c ^-l`; then
12172 <                    CGAL_LIBS="$CGAL_LIBS $i"
12173 <                else
12174 <                    CGAL_LDFLAGS="$CGAL_LDFLAGS $i"
12175 <                fi
12176 <            done
12177 <            rm -f $tname
12178 <            { echo "$as_me:$LINENO: result: yes" >&5
12179 < echo "${ECHO_T}yes" >&6; }
12180 <            acx_cgal_found=yes
12181 <                                   else
12182 <            { echo "$as_me:$LINENO: result: invalid" >&5
12183 < echo "${ECHO_T}invalid" >&6; }
12184 <            { { echo "$as_me:$LINENO: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&5
12185 < echo "$as_me: error: CGAL_MAKEFILE defined, but the makefile does not exist." >&2;}
12186 <   { (exit 1); exit 1; }; }
12187 <        fi
12188 <    else
12189 <        { echo "$as_me:$LINENO: result: not defined" >&5
12190 < echo "${ECHO_T}not defined" >&6; }
12191 <    fi
12192 < fi
12193 <
12194 < if test "$acx_cgal_found" == no; then
12195 <        if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12196 <  { echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12197 < echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6; }
12198 < if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12199 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12200 < fi
12201 < { echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12202 < echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12203 < else
12204 <  # Is the header compilable?
12205 < { echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability" >&5
12206 < echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h usability... $ECHO_C" >&6; }
12207 < cat >conftest.$ac_ext <<_ACEOF
12208 < /* confdefs.h.  */
12209 < _ACEOF
12210 < cat confdefs.h >>conftest.$ac_ext
12211 < cat >>conftest.$ac_ext <<_ACEOF
12212 < /* end confdefs.h.  */
12213 < $ac_includes_default
12214 < #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12215 < _ACEOF
12216 < rm -f conftest.$ac_objext
12217 < if { (ac_try="$ac_compile"
12218 < case "(($ac_try" in
12219 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12220 <  *) ac_try_echo=$ac_try;;
12221 < esac
12222 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12223 <  (eval "$ac_compile") 2>conftest.er1
12224 <  ac_status=$?
12225 <  grep -v '^ *+' conftest.er1 >conftest.err
12226 <  rm -f conftest.er1
12227 <  cat conftest.err >&5
12228 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12229 <  (exit $ac_status); } && {
12230 <         test -z "$ac_c_werror_flag" ||
12231 <         test ! -s conftest.err
12232 <       } && test -s conftest.$ac_objext; then
12233 <  ac_header_compiler=yes
12234 < else
12235 <  echo "$as_me: failed program was:" >&5
12236 < sed 's/^/| /' conftest.$ac_ext >&5
12237 <
12238 <        ac_header_compiler=no
12239 < fi
12240 <
12241 < rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
12242 < { echo "$as_me:$LINENO: result: $ac_header_compiler" >&5
12243 < echo "${ECHO_T}$ac_header_compiler" >&6; }
12244 <
12245 < # Is the header present?
12246 < { echo "$as_me:$LINENO: checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence" >&5
12247 < echo $ECHO_N "checking CGAL/Exact_predicates_inexact_constructions_kernel.h presence... $ECHO_C" >&6; }
12248 < cat >conftest.$ac_ext <<_ACEOF
12249 < /* confdefs.h.  */
12250 < _ACEOF
12251 < cat confdefs.h >>conftest.$ac_ext
12252 < cat >>conftest.$ac_ext <<_ACEOF
12253 < /* end confdefs.h.  */
12254 < #include <CGAL/Exact_predicates_inexact_constructions_kernel.h>
12255 < _ACEOF
12256 < if { (ac_try="$ac_cpp conftest.$ac_ext"
12257 < case "(($ac_try" in
12258 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12259 <  *) ac_try_echo=$ac_try;;
12260 < esac
12261 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12262 <  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
12263 <  ac_status=$?
12264 <  grep -v '^ *+' conftest.er1 >conftest.err
12265 <  rm -f conftest.er1
12266 <  cat conftest.err >&5
12267 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12268 <  (exit $ac_status); } >/dev/null && {
12269 <         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
12270 <         test ! -s conftest.err
12271 <       }; then
12272 <  ac_header_preproc=yes
12273 < else
12274 <  echo "$as_me: failed program was:" >&5
12275 < sed 's/^/| /' conftest.$ac_ext >&5
12276 <
12277 <  ac_header_preproc=no
12278 < fi
12279 <
12280 < rm -f conftest.err conftest.$ac_ext
12281 < { echo "$as_me:$LINENO: result: $ac_header_preproc" >&5
12282 < echo "${ECHO_T}$ac_header_preproc" >&6; }
12283 <
12284 < # So?  What about this header?
12285 < case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in
12286 <  yes:no: )
12287 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&5
12288 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: accepted by the compiler, rejected by the preprocessor!" >&2;}
12289 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&5
12290 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the compiler's result" >&2;}
12291 <    ac_header_preproc=yes
12292 <    ;;
12293 <  no:yes:* )
12294 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&5
12295 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: present but cannot be compiled" >&2;}
12296 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&5
12297 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     check for missing prerequisite headers?" >&2;}
12298 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&5
12299 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: see the Autoconf documentation" >&2;}
12300 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&5
12301 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h:     section \"Present But Cannot Be Compiled\"" >&2;}
12302 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&5
12303 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: proceeding with the preprocessor's result" >&2;}
12304 <    { echo "$as_me:$LINENO: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&5
12305 < echo "$as_me: WARNING: CGAL/Exact_predicates_inexact_constructions_kernel.h: in the future, the compiler will take precedence" >&2;}
12306 <    ( cat <<\_ASBOX
12307 < ## ------------------------------ ##
12308 < ## Report this to gezelter@nd.edu ##
12309 < ## ------------------------------ ##
12310 < _ASBOX
12311 <     ) | sed "s/^/$as_me: WARNING:     /" >&2
12312 <    ;;
12313 < esac
12314 < { echo "$as_me:$LINENO: checking for CGAL/Exact_predicates_inexact_constructions_kernel.h" >&5
12315 < echo $ECHO_N "checking for CGAL/Exact_predicates_inexact_constructions_kernel.h... $ECHO_C" >&6; }
12316 < if test "${ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h+set}" = set; then
12317 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12318 < else
12319 <  ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h=$ac_header_preproc
12320 < fi
12321 < { echo "$as_me:$LINENO: result: $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&5
12322 < echo "${ECHO_T}$ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h" >&6; }
12323 <
12324 < fi
12325 < if test $ac_cv_header_CGAL_Exact_predicates_inexact_constructions_kernel_h = yes; then
12326 <  cgal_have_header=yes
12327 < else
12328 <  cgal_have_header=no
12329 < fi
12330 <
12331 <
12332 <        if test "$cgal_have_header" == yes; then
12333 <                { echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
12334 < echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6; }
12335 < if test "${ac_cv_lib_CGAL_main+set}" = set; then
12336 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12337 < else
12338 <  ac_check_lib_save_LIBS=$LIBS
12339 < LIBS="-lCGAL  $LIBS"
12340 < cat >conftest.$ac_ext <<_ACEOF
12341 < /* confdefs.h.  */
12342 < _ACEOF
12343 < cat confdefs.h >>conftest.$ac_ext
12344 < cat >>conftest.$ac_ext <<_ACEOF
12345 < /* end confdefs.h.  */
12346 <
12347 <
12348 < #ifdef FC_DUMMY_MAIN
12349 < #ifndef FC_DUMMY_MAIN_EQ_F77
12350 < #  ifdef __cplusplus
12351 <     extern "C"
12352 < #  endif
12353 <   int FC_DUMMY_MAIN() { return 1; }
12354 < #endif
12355 < #endif
12356 < int
12357 < main ()
12358 < {
12359 < return main ();
12360 <  ;
12361 <  return 0;
12362 < }
12363 < _ACEOF
12364 < rm -f conftest.$ac_objext conftest$ac_exeext
12365 < if { (ac_try="$ac_link"
12366 < case "(($ac_try" in
12367 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12368 <  *) ac_try_echo=$ac_try;;
12369 < esac
12370 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12371 <  (eval "$ac_link") 2>conftest.er1
12372 <  ac_status=$?
12373 <  grep -v '^ *+' conftest.er1 >conftest.err
12374 <  rm -f conftest.er1
12375 <  cat conftest.err >&5
12376 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12377 <  (exit $ac_status); } && {
12378 <         test -z "$ac_c_werror_flag" ||
12379 <         test ! -s conftest.err
12380 <       } && test -s conftest$ac_exeext &&
12381 <       $as_test_x conftest$ac_exeext; then
12382 <  ac_cv_lib_CGAL_main=yes
12383 < else
12384 <  echo "$as_me: failed program was:" >&5
12385 < sed 's/^/| /' conftest.$ac_ext >&5
12386 <
12387 <        ac_cv_lib_CGAL_main=no
12388 < fi
12389 <
12390 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12391 <      conftest$ac_exeext conftest.$ac_ext
12392 < LIBS=$ac_check_lib_save_LIBS
12393 < fi
12394 < { echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
12395 < echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6; }
12396 < if test $ac_cv_lib_CGAL_main = yes; then
12397 <  cgal_have_lib=yes
12398 < else
12399 <  cgal_have_lib=no
12400 < fi
12401 <
12402 <                if test "$cgal_have_lib" == no; then
12403 <                        save_LIBS="$LIBS"; LIBS="$LIBS -lgmp -lmpfr -lm"
12404 <                        { echo "$as_me:$LINENO: checking for main in -lCGAL" >&5
12405 < echo $ECHO_N "checking for main in -lCGAL... $ECHO_C" >&6; }
12406 < if test "${ac_cv_lib_CGAL_main+set}" = set; then
12407 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12408 < else
12409 <  ac_check_lib_save_LIBS=$LIBS
12410 < LIBS="-lCGAL  $LIBS"
12411 < cat >conftest.$ac_ext <<_ACEOF
12412 < /* confdefs.h.  */
12413 < _ACEOF
12414 < cat confdefs.h >>conftest.$ac_ext
12415 < cat >>conftest.$ac_ext <<_ACEOF
12416 < /* end confdefs.h.  */
12417 <
12418 <
12419 < #ifdef FC_DUMMY_MAIN
12420 < #ifndef FC_DUMMY_MAIN_EQ_F77
12421 < #  ifdef __cplusplus
12422 <     extern "C"
12423 < #  endif
12424 <   int FC_DUMMY_MAIN() { return 1; }
12425 < #endif
12426 < #endif
12427 < int
12428 < main ()
12429 < {
12430 < return main ();
12431 <  ;
12432 <  return 0;
12433 < }
12434 < _ACEOF
12435 < rm -f conftest.$ac_objext conftest$ac_exeext
12436 < if { (ac_try="$ac_link"
12437 < case "(($ac_try" in
12438 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12439 <  *) ac_try_echo=$ac_try;;
12440 < esac
12441 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12442 <  (eval "$ac_link") 2>conftest.er1
12443 <  ac_status=$?
12444 <  grep -v '^ *+' conftest.er1 >conftest.err
12445 <  rm -f conftest.er1
12446 <  cat conftest.err >&5
12447 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12448 <  (exit $ac_status); } && {
12449 <         test -z "$ac_c_werror_flag" ||
12450 <         test ! -s conftest.err
12451 <       } && test -s conftest$ac_exeext &&
12452 <       $as_test_x conftest$ac_exeext; then
12453 <  ac_cv_lib_CGAL_main=yes
12454 < else
12455 <  echo "$as_me: failed program was:" >&5
12456 < sed 's/^/| /' conftest.$ac_ext >&5
12457 <
12458 <        ac_cv_lib_CGAL_main=no
12459 < fi
12460 <
12461 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12462 <      conftest$ac_exeext conftest.$ac_ext
12463 < LIBS=$ac_check_lib_save_LIBS
12464 < fi
12465 < { echo "$as_me:$LINENO: result: $ac_cv_lib_CGAL_main" >&5
12466 < echo "${ECHO_T}$ac_cv_lib_CGAL_main" >&6; }
12467 < if test $ac_cv_lib_CGAL_main = yes; then
12468 <  CGAL_LIBS="-lCGAL -lgmp -lmpfr"
12469 <                                                  cgal_have_lib=yes
12470 < else
12471 <  cgal_have_lib=no
12472 < fi
12473 <
12474 <                        LIBS="$save_LIBS"
12475 <                else
12476 <                        CGAL_LIBS="-lCGAL"
12477 <                        { echo "$as_me:$LINENO: checking for main in -lmpfr" >&5
12478 < echo $ECHO_N "checking for main in -lmpfr... $ECHO_C" >&6; }
12479 < if test "${ac_cv_lib_mpfr_main+set}" = set; then
12480 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12481 < else
12482 <  ac_check_lib_save_LIBS=$LIBS
12483 < LIBS="-lmpfr  $LIBS"
12484 < cat >conftest.$ac_ext <<_ACEOF
12485 < /* confdefs.h.  */
12486 < _ACEOF
12487 < cat confdefs.h >>conftest.$ac_ext
12488 < cat >>conftest.$ac_ext <<_ACEOF
6179 > fi
6180 >
6181 > if test $ac_cv_header_stdc = yes; then
6182 >  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6183 >  if test "$cross_compiling" = yes; then :
6184 >  :
6185 > else
6186 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6187 > /* end confdefs.h.  */
6188 > #include <ctype.h>
6189 > #include <stdlib.h>
6190 > #if ((' ' & 0x0FF) == 0x020)
6191 > # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6192 > # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6193 > #else
6194 > # define ISLOWER(c) \
6195 >                   (('a' <= (c) && (c) <= 'i') \
6196 >                     || ('j' <= (c) && (c) <= 'r') \
6197 >                     || ('s' <= (c) && (c) <= 'z'))
6198 > # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6199 > #endif
6200 >
6201 > #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6202 > int
6203 > main ()
6204 > {
6205 >  int i;
6206 >  for (i = 0; i < 256; i++)
6207 >    if (XOR (islower (i), ISLOWER (i))
6208 >        || toupper (i) != TOUPPER (i))
6209 >      return 2;
6210 >  return 0;
6211 > }
6212 > _ACEOF
6213 > if ac_fn_c_try_run "$LINENO"; then :
6214 >
6215 > else
6216 >  ac_cv_header_stdc=no
6217 > fi
6218 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6219 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6220 > fi
6221 >
6222 > fi
6223 > fi
6224 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
6225 > $as_echo "$ac_cv_header_stdc" >&6; }
6226 > if test $ac_cv_header_stdc = yes; then
6227 >
6228 > $as_echo "#define STDC_HEADERS 1" >>confdefs.h
6229 >
6230 > fi
6231 >
6232 > for ac_header in libintl.h limits.h machine/hal_sysinfo.h stdlib.h string.h strings.h sys/param.h sys/pstat.h sys/sysctl.h sys/sysinfo.h sys/sysmp.h sys/systemcfg.h sys/table.h sys/time.h unistd.h
6233 > do :
6234 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6235 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
6236 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
6237 >  cat >>confdefs.h <<_ACEOF
6238 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6239 > _ACEOF
6240 >
6241 > fi
6242 >
6243 > done
6244 >
6245 >
6246 > # Checks for typedefs, structures, and compiler characteristics.
6247 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for stdbool.h that conforms to C99" >&5
6248 > $as_echo_n "checking for stdbool.h that conforms to C99... " >&6; }
6249 > if ${ac_cv_header_stdbool_h+:} false; then :
6250 >  $as_echo_n "(cached) " >&6
6251 > else
6252 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6253 > /* end confdefs.h.  */
6254 >
6255 > #include <stdbool.h>
6256 > #ifndef bool
6257 > "error: bool is not defined"
6258 > #endif
6259 > #ifndef false
6260 > "error: false is not defined"
6261 > #endif
6262 > #if false
6263 > "error: false is not 0"
6264 > #endif
6265 > #ifndef true
6266 > "error: true is not defined"
6267 > #endif
6268 > #if true != 1
6269 > "error: true is not 1"
6270 > #endif
6271 > #ifndef __bool_true_false_are_defined
6272 > "error: __bool_true_false_are_defined is not defined"
6273 > #endif
6274 >
6275 >        struct s { _Bool s: 1; _Bool t; } s;
6276 >
6277 >        char a[true == 1 ? 1 : -1];
6278 >        char b[false == 0 ? 1 : -1];
6279 >        char c[__bool_true_false_are_defined == 1 ? 1 : -1];
6280 >        char d[(bool) 0.5 == true ? 1 : -1];
6281 >        /* See body of main program for 'e'.  */
6282 >        char f[(_Bool) 0.0 == false ? 1 : -1];
6283 >        char g[true];
6284 >        char h[sizeof (_Bool)];
6285 >        char i[sizeof s.t];
6286 >        enum { j = false, k = true, l = false * true, m = true * 256 };
6287 >        /* The following fails for
6288 >           HP aC++/ANSI C B3910B A.05.55 [Dec 04 2003]. */
6289 >        _Bool n[m];
6290 >        char o[sizeof n == m * sizeof n[0] ? 1 : -1];
6291 >        char p[-1 - (_Bool) 0 < 0 && -1 - (bool) 0 < 0 ? 1 : -1];
6292 >        /* Catch a bug in an HP-UX C compiler.  See
6293 >           http://gcc.gnu.org/ml/gcc-patches/2003-12/msg02303.html
6294 >           http://lists.gnu.org/archive/html/bug-coreutils/2005-11/msg00161.html
6295 >         */
6296 >        _Bool q = true;
6297 >        _Bool *pq = &q;
6298 >
6299 > int
6300 > main ()
6301 > {
6302 >
6303 >        bool e = &s;
6304 >        *pq |= q;
6305 >        *pq |= ! q;
6306 >        /* Refer to every declared value, to avoid compiler optimizations.  */
6307 >        return (!a + !b + !c + !d + !e + !f + !g + !h + !i + !!j + !k + !!l
6308 >                + !m + !n + !o + !p + !q + !pq);
6309 >
6310 >  ;
6311 >  return 0;
6312 > }
6313 > _ACEOF
6314 > if ac_fn_c_try_compile "$LINENO"; then :
6315 >  ac_cv_header_stdbool_h=yes
6316 > else
6317 >  ac_cv_header_stdbool_h=no
6318 > fi
6319 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6320 > fi
6321 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdbool_h" >&5
6322 > $as_echo "$ac_cv_header_stdbool_h" >&6; }
6323 > ac_fn_c_check_type "$LINENO" "_Bool" "ac_cv_type__Bool" "$ac_includes_default"
6324 > if test "x$ac_cv_type__Bool" = xyes; then :
6325 >
6326 > cat >>confdefs.h <<_ACEOF
6327 > #define HAVE__BOOL 1
6328 > _ACEOF
6329 >
6330 >
6331 > fi
6332 >
6333 > if test $ac_cv_header_stdbool_h = yes; then
6334 >
6335 > $as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h
6336 >
6337 > fi
6338 >
6339 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5
6340 > $as_echo_n "checking for an ANSI C-conforming const... " >&6; }
6341 > if ${ac_cv_c_const+:} false; then :
6342 >  $as_echo_n "(cached) " >&6
6343 > else
6344 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6345 > /* end confdefs.h.  */
6346 >
6347 > int
6348 > main ()
6349 > {
6350 > /* FIXME: Include the comments suggested by Paul. */
6351 > #ifndef __cplusplus
6352 >  /* Ultrix mips cc rejects this.  */
6353 >  typedef int charset[2];
6354 >  const charset cs;
6355 >  /* SunOS 4.1.1 cc rejects this.  */
6356 >  char const *const *pcpcc;
6357 >  char **ppc;
6358 >  /* NEC SVR4.0.2 mips cc rejects this.  */
6359 >  struct point {int x, y;};
6360 >  static struct point const zero = {0,0};
6361 >  /* AIX XL C 1.02.0.0 rejects this.
6362 >     It does not let you subtract one const X* pointer from another in
6363 >     an arm of an if-expression whose if-part is not a constant
6364 >     expression */
6365 >  const char *g = "string";
6366 >  pcpcc = &g + (g ? g-g : 0);
6367 >  /* HPUX 7.0 cc rejects these. */
6368 >  ++pcpcc;
6369 >  ppc = (char**) pcpcc;
6370 >  pcpcc = (char const *const *) ppc;
6371 >  { /* SCO 3.2v4 cc rejects this.  */
6372 >    char *t;
6373 >    char const *s = 0 ? (char *) 0 : (char const *) 0;
6374 >
6375 >    *t++ = 0;
6376 >    if (s) return 0;
6377 >  }
6378 >  { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
6379 >    int x[] = {25, 17};
6380 >    const int *foo = &x[0];
6381 >    ++foo;
6382 >  }
6383 >  { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
6384 >    typedef const int *iptr;
6385 >    iptr p = 0;
6386 >    ++p;
6387 >  }
6388 >  { /* AIX XL C 1.02.0.0 rejects this saying
6389 >       "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
6390 >    struct s { int j; const int *ap[3]; };
6391 >    struct s *b; b->j = 5;
6392 >  }
6393 >  { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
6394 >    const int foo = 10;
6395 >    if (!foo) return 0;
6396 >  }
6397 >  return !cs[0] && !zero.x;
6398 > #endif
6399 >
6400 >  ;
6401 >  return 0;
6402 > }
6403 > _ACEOF
6404 > if ac_fn_c_try_compile "$LINENO"; then :
6405 >  ac_cv_c_const=yes
6406 > else
6407 >  ac_cv_c_const=no
6408 > fi
6409 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6410 > fi
6411 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5
6412 > $as_echo "$ac_cv_c_const" >&6; }
6413 > if test $ac_cv_c_const = no; then
6414 >
6415 > $as_echo "#define const /**/" >>confdefs.h
6416 >
6417 > fi
6418 >
6419 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5
6420 > $as_echo_n "checking for inline... " >&6; }
6421 > if ${ac_cv_c_inline+:} false; then :
6422 >  $as_echo_n "(cached) " >&6
6423 > else
6424 >  ac_cv_c_inline=no
6425 > for ac_kw in inline __inline__ __inline; do
6426 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6427 > /* end confdefs.h.  */
6428 > #ifndef __cplusplus
6429 > typedef int foo_t;
6430 > static $ac_kw foo_t static_foo () {return 0; }
6431 > $ac_kw foo_t foo () {return 0; }
6432 > #endif
6433 >
6434 > _ACEOF
6435 > if ac_fn_c_try_compile "$LINENO"; then :
6436 >  ac_cv_c_inline=$ac_kw
6437 > fi
6438 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6439 >  test "$ac_cv_c_inline" != no && break
6440 > done
6441 >
6442 > fi
6443 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5
6444 > $as_echo "$ac_cv_c_inline" >&6; }
6445 >
6446 > case $ac_cv_c_inline in
6447 >  inline | yes) ;;
6448 >  *)
6449 >    case $ac_cv_c_inline in
6450 >      no) ac_val=;;
6451 >      *) ac_val=$ac_cv_c_inline;;
6452 >    esac
6453 >    cat >>confdefs.h <<_ACEOF
6454 > #ifndef __cplusplus
6455 > #define inline $ac_val
6456 > #endif
6457 > _ACEOF
6458 >    ;;
6459 > esac
6460 >
6461 > ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default"
6462 > if test "x$ac_cv_type_size_t" = xyes; then :
6463 >
6464 > else
6465 >
6466 > cat >>confdefs.h <<_ACEOF
6467 > #define size_t unsigned int
6468 > _ACEOF
6469 >
6470 > fi
6471 >
6472 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether time.h and sys/time.h may both be included" >&5
6473 > $as_echo_n "checking whether time.h and sys/time.h may both be included... " >&6; }
6474 > if ${ac_cv_header_time+:} false; then :
6475 >  $as_echo_n "(cached) " >&6
6476 > else
6477 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6478 > /* end confdefs.h.  */
6479 > #include <sys/types.h>
6480 > #include <sys/time.h>
6481 > #include <time.h>
6482 >
6483 > int
6484 > main ()
6485 > {
6486 > if ((struct tm *) 0)
6487 > return 0;
6488 >  ;
6489 >  return 0;
6490 > }
6491 > _ACEOF
6492 > if ac_fn_c_try_compile "$LINENO"; then :
6493 >  ac_cv_header_time=yes
6494 > else
6495 >  ac_cv_header_time=no
6496 > fi
6497 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6498 > fi
6499 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_time" >&5
6500 > $as_echo "$ac_cv_header_time" >&6; }
6501 > if test $ac_cv_header_time = yes; then
6502 >
6503 > $as_echo "#define TIME_WITH_SYS_TIME 1" >>confdefs.h
6504 >
6505 > fi
6506 >
6507 >
6508 > # Checks for library functions.
6509 > for ac_header in stdlib.h
6510 > do :
6511 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6512 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6513 >  cat >>confdefs.h <<_ACEOF
6514 > #define HAVE_STDLIB_H 1
6515 > _ACEOF
6516 >
6517 > fi
6518 >
6519 > done
6520 >
6521 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible malloc" >&5
6522 > $as_echo_n "checking for GNU libc compatible malloc... " >&6; }
6523 > if ${ac_cv_func_malloc_0_nonnull+:} false; then :
6524 >  $as_echo_n "(cached) " >&6
6525 > else
6526 >  if test "$cross_compiling" = yes; then :
6527 >  ac_cv_func_malloc_0_nonnull=no
6528 > else
6529 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6530 > /* end confdefs.h.  */
6531 > #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6532 > # include <stdlib.h>
6533 > #else
6534 > char *malloc ();
6535 > #endif
6536 >
6537 > int
6538 > main ()
6539 > {
6540 > return ! malloc (0);
6541 >  ;
6542 >  return 0;
6543 > }
6544 > _ACEOF
6545 > if ac_fn_c_try_run "$LINENO"; then :
6546 >  ac_cv_func_malloc_0_nonnull=yes
6547 > else
6548 >  ac_cv_func_malloc_0_nonnull=no
6549 > fi
6550 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6551 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6552 > fi
6553 >
6554 > fi
6555 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_malloc_0_nonnull" >&5
6556 > $as_echo "$ac_cv_func_malloc_0_nonnull" >&6; }
6557 > if test $ac_cv_func_malloc_0_nonnull = yes; then :
6558 >
6559 > $as_echo "#define HAVE_MALLOC 1" >>confdefs.h
6560 >
6561 > else
6562 >  $as_echo "#define HAVE_MALLOC 0" >>confdefs.h
6563 >
6564 >   case " $LIBOBJS " in
6565 >  *" malloc.$ac_objext "* ) ;;
6566 >  *) LIBOBJS="$LIBOBJS malloc.$ac_objext"
6567 > ;;
6568 > esac
6569 >
6570 >
6571 > $as_echo "#define malloc rpl_malloc" >>confdefs.h
6572 >
6573 > fi
6574 >
6575 >
6576 > for ac_header in stdlib.h
6577 > do :
6578 >  ac_fn_c_check_header_mongrel "$LINENO" "stdlib.h" "ac_cv_header_stdlib_h" "$ac_includes_default"
6579 > if test "x$ac_cv_header_stdlib_h" = xyes; then :
6580 >  cat >>confdefs.h <<_ACEOF
6581 > #define HAVE_STDLIB_H 1
6582 > _ACEOF
6583 >
6584 > fi
6585 >
6586 > done
6587 >
6588 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU libc compatible realloc" >&5
6589 > $as_echo_n "checking for GNU libc compatible realloc... " >&6; }
6590 > if ${ac_cv_func_realloc_0_nonnull+:} false; then :
6591 >  $as_echo_n "(cached) " >&6
6592 > else
6593 >  if test "$cross_compiling" = yes; then :
6594 >  ac_cv_func_realloc_0_nonnull=no
6595 > else
6596 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6597 > /* end confdefs.h.  */
6598 > #if defined STDC_HEADERS || defined HAVE_STDLIB_H
6599 > # include <stdlib.h>
6600 > #else
6601 > char *realloc ();
6602 > #endif
6603 >
6604 > int
6605 > main ()
6606 > {
6607 > return ! realloc (0, 0);
6608 >  ;
6609 >  return 0;
6610 > }
6611 > _ACEOF
6612 > if ac_fn_c_try_run "$LINENO"; then :
6613 >  ac_cv_func_realloc_0_nonnull=yes
6614 > else
6615 >  ac_cv_func_realloc_0_nonnull=no
6616 > fi
6617 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6618 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6619 > fi
6620 >
6621 > fi
6622 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_realloc_0_nonnull" >&5
6623 > $as_echo "$ac_cv_func_realloc_0_nonnull" >&6; }
6624 > if test $ac_cv_func_realloc_0_nonnull = yes; then :
6625 >
6626 > $as_echo "#define HAVE_REALLOC 1" >>confdefs.h
6627 >
6628 > else
6629 >  $as_echo "#define HAVE_REALLOC 0" >>confdefs.h
6630 >
6631 >   case " $LIBOBJS " in
6632 >  *" realloc.$ac_objext "* ) ;;
6633 >  *) LIBOBJS="$LIBOBJS realloc.$ac_objext"
6634 > ;;
6635 > esac
6636 >
6637 >
6638 > $as_echo "#define realloc rpl_realloc" >>confdefs.h
6639 >
6640 > fi
6641 >
6642 >
6643 > for ac_header in sys/select.h sys/socket.h
6644 > do :
6645 >  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
6646 > ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
6647 > if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
6648 >  cat >>confdefs.h <<_ACEOF
6649 > #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
6650 > _ACEOF
6651 >
6652 > fi
6653 >
6654 > done
6655 >
6656 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking types of arguments for select" >&5
6657 > $as_echo_n "checking types of arguments for select... " >&6; }
6658 > if ${ac_cv_func_select_args+:} false; then :
6659 >  $as_echo_n "(cached) " >&6
6660 > else
6661 >  for ac_arg234 in 'fd_set *' 'int *' 'void *'; do
6662 > for ac_arg1 in 'int' 'size_t' 'unsigned long int' 'unsigned int'; do
6663 >  for ac_arg5 in 'struct timeval *' 'const struct timeval *'; do
6664 >   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6665 > /* end confdefs.h.  */
6666 > $ac_includes_default
6667 > #ifdef HAVE_SYS_SELECT_H
6668 > # include <sys/select.h>
6669 > #endif
6670 > #ifdef HAVE_SYS_SOCKET_H
6671 > # include <sys/socket.h>
6672 > #endif
6673 >
6674 > int
6675 > main ()
6676 > {
6677 > extern int select ($ac_arg1,
6678 >                                            $ac_arg234, $ac_arg234, $ac_arg234,
6679 >                                            $ac_arg5);
6680 >  ;
6681 >  return 0;
6682 > }
6683 > _ACEOF
6684 > if ac_fn_c_try_compile "$LINENO"; then :
6685 >  ac_cv_func_select_args="$ac_arg1,$ac_arg234,$ac_arg5"; break 3
6686 > fi
6687 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6688 >  done
6689 > done
6690 > done
6691 > # Provide a safe default value.
6692 > : "${ac_cv_func_select_args=int,int *,struct timeval *}"
6693 >
6694 > fi
6695 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_select_args" >&5
6696 > $as_echo "$ac_cv_func_select_args" >&6; }
6697 > ac_save_IFS=$IFS; IFS=','
6698 > set dummy `echo "$ac_cv_func_select_args" | sed 's/\*/\*/g'`
6699 > IFS=$ac_save_IFS
6700 > shift
6701 >
6702 > cat >>confdefs.h <<_ACEOF
6703 > #define SELECT_TYPE_ARG1 $1
6704 > _ACEOF
6705 >
6706 >
6707 > cat >>confdefs.h <<_ACEOF
6708 > #define SELECT_TYPE_ARG234 ($2)
6709 > _ACEOF
6710 >
6711 >
6712 > cat >>confdefs.h <<_ACEOF
6713 > #define SELECT_TYPE_ARG5 ($3)
6714 > _ACEOF
6715 >
6716 > rm -f conftest*
6717 >
6718 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working strtod" >&5
6719 > $as_echo_n "checking for working strtod... " >&6; }
6720 > if ${ac_cv_func_strtod+:} false; then :
6721 >  $as_echo_n "(cached) " >&6
6722 > else
6723 >  if test "$cross_compiling" = yes; then :
6724 >  ac_cv_func_strtod=no
6725 > else
6726 >  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6727   /* end confdefs.h.  */
6728  
6729 <
6730 < #ifdef FC_DUMMY_MAIN
6731 < #ifndef FC_DUMMY_MAIN_EQ_F77
12494 < #  ifdef __cplusplus
12495 <     extern "C"
12496 < #  endif
12497 <   int FC_DUMMY_MAIN() { return 1; }
6729 > $ac_includes_default
6730 > #ifndef strtod
6731 > double strtod ();
6732   #endif
12499 – #endif
6733   int
6734 < main ()
6734 > main()
6735   {
6736 < return main ();
6737 <  ;
6736 >  {
6737 >    /* Some versions of Linux strtod mis-parse strings with leading '+'.  */
6738 >    char *string = " +69";
6739 >    char *term;
6740 >    double value;
6741 >    value = strtod (string, &term);
6742 >    if (value != 69 || term != (string + 4))
6743 >      return 1;
6744 >  }
6745 >
6746 >  {
6747 >    /* Under Solaris 2.4, strtod returns the wrong value for the
6748 >       terminating character under some conditions.  */
6749 >    char *string = "NaN";
6750 >    char *term;
6751 >    strtod (string, &term);
6752 >    if (term != string && *(term - 1) == 0)
6753 >      return 1;
6754 >  }
6755    return 0;
6756   }
6757 +
6758   _ACEOF
6759 < rm -f conftest.$ac_objext conftest$ac_exeext
6760 < if { (ac_try="$ac_link"
12510 < case "(($ac_try" in
12511 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12512 <  *) ac_try_echo=$ac_try;;
12513 < esac
12514 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12515 <  (eval "$ac_link") 2>conftest.er1
12516 <  ac_status=$?
12517 <  grep -v '^ *+' conftest.er1 >conftest.err
12518 <  rm -f conftest.er1
12519 <  cat conftest.err >&5
12520 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12521 <  (exit $ac_status); } && {
12522 <         test -z "$ac_c_werror_flag" ||
12523 <         test ! -s conftest.err
12524 <       } && test -s conftest$ac_exeext &&
12525 <       $as_test_x conftest$ac_exeext; then
12526 <  ac_cv_lib_mpfr_main=yes
6759 > if ac_fn_c_try_run "$LINENO"; then :
6760 >  ac_cv_func_strtod=yes
6761   else
6762 <  echo "$as_me: failed program was:" >&5
6763 < sed 's/^/| /' conftest.$ac_ext >&5
6762 >  ac_cv_func_strtod=no
6763 > fi
6764 > rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
6765 >  conftest.$ac_objext conftest.beam conftest.$ac_ext
6766 > fi
6767  
12531 –        ac_cv_lib_mpfr_main=no
6768   fi
6769 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_strtod" >&5
6770 + $as_echo "$ac_cv_func_strtod" >&6; }
6771 + if test $ac_cv_func_strtod = no; then
6772 +  case " $LIBOBJS " in
6773 +  *" strtod.$ac_objext "* ) ;;
6774 +  *) LIBOBJS="$LIBOBJS strtod.$ac_objext"
6775 + ;;
6776 + esac
6777  
6778 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6779 <      conftest$ac_exeext conftest.$ac_ext
6780 < LIBS=$ac_check_lib_save_LIBS
6778 > ac_fn_c_check_func "$LINENO" "pow" "ac_cv_func_pow"
6779 > if test "x$ac_cv_func_pow" = xyes; then :
6780 >
6781   fi
12538 – { echo "$as_me:$LINENO: result: $ac_cv_lib_mpfr_main" >&5
12539 – echo "${ECHO_T}$ac_cv_lib_mpfr_main" >&6; }
12540 – if test $ac_cv_lib_mpfr_main = yes; then
12541 –  CGAL_LIBS="$CGAL_LIBS -lmpfr"
12542 – fi
6782  
6783 <                        { echo "$as_me:$LINENO: checking for main in -lgmp" >&5
6784 < echo $ECHO_N "checking for main in -lgmp... $ECHO_C" >&6; }
6785 < if test "${ac_cv_lib_gmp_main+set}" = set; then
6786 <  echo $ECHO_N "(cached) $ECHO_C" >&6
6783 > if test $ac_cv_func_pow = no; then
6784 >  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pow in -lm" >&5
6785 > $as_echo_n "checking for pow in -lm... " >&6; }
6786 > if ${ac_cv_lib_m_pow+:} false; then :
6787 >  $as_echo_n "(cached) " >&6
6788   else
6789    ac_check_lib_save_LIBS=$LIBS
6790 < LIBS="-lgmp  $LIBS"
6791 < cat >conftest.$ac_ext <<_ACEOF
12552 < /* confdefs.h.  */
12553 < _ACEOF
12554 < cat confdefs.h >>conftest.$ac_ext
12555 < cat >>conftest.$ac_ext <<_ACEOF
6790 > LIBS="-lm  $LIBS"
6791 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6792   /* end confdefs.h.  */
6793  
6794 <
6795 < #ifdef FC_DUMMY_MAIN
6796 < #ifndef FC_DUMMY_MAIN_EQ_F77
6797 < #  ifdef __cplusplus
6798 <     extern "C"
12563 < #  endif
12564 <   int FC_DUMMY_MAIN() { return 1; }
6794 > /* Override any GCC internal prototype to avoid an error.
6795 >   Use char because int might match the return type of a GCC
6796 >   builtin and then its argument prototype would still apply.  */
6797 > #ifdef __cplusplus
6798 > extern "C"
6799   #endif
6800 < #endif
6800 > char pow ();
6801   int
6802   main ()
6803   {
6804 < return main ();
6804 > return pow ();
6805    ;
6806    return 0;
6807   }
6808   _ACEOF
6809 < rm -f conftest.$ac_objext conftest$ac_exeext
6810 < if { (ac_try="$ac_link"
12577 < case "(($ac_try" in
12578 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12579 <  *) ac_try_echo=$ac_try;;
12580 < esac
12581 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12582 <  (eval "$ac_link") 2>conftest.er1
12583 <  ac_status=$?
12584 <  grep -v '^ *+' conftest.er1 >conftest.err
12585 <  rm -f conftest.er1
12586 <  cat conftest.err >&5
12587 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12588 <  (exit $ac_status); } && {
12589 <         test -z "$ac_c_werror_flag" ||
12590 <         test ! -s conftest.err
12591 <       } && test -s conftest$ac_exeext &&
12592 <       $as_test_x conftest$ac_exeext; then
12593 <  ac_cv_lib_gmp_main=yes
6809 > if ac_fn_c_try_link "$LINENO"; then :
6810 >  ac_cv_lib_m_pow=yes
6811   else
6812 <  echo "$as_me: failed program was:" >&5
12596 < sed 's/^/| /' conftest.$ac_ext >&5
12597 <
12598 <        ac_cv_lib_gmp_main=no
6812 >  ac_cv_lib_m_pow=no
6813   fi
6814 <
6815 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12602 <      conftest$ac_exeext conftest.$ac_ext
6814 > rm -f core conftest.err conftest.$ac_objext \
6815 >    conftest$ac_exeext conftest.$ac_ext
6816   LIBS=$ac_check_lib_save_LIBS
6817   fi
6818 < { echo "$as_me:$LINENO: result: $ac_cv_lib_gmp_main" >&5
6819 < echo "${ECHO_T}$ac_cv_lib_gmp_main" >&6; }
6820 < if test $ac_cv_lib_gmp_main = yes; then
6821 <  CGAL_LIBS="$CGAL_LIBS -lgmp"
6818 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_pow" >&5
6819 > $as_echo "$ac_cv_lib_m_pow" >&6; }
6820 > if test "x$ac_cv_lib_m_pow" = xyes; then :
6821 >  POW_LIB=-lm
6822 > else
6823 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cannot find library containing definition of pow" >&5
6824 > $as_echo "$as_me: WARNING: cannot find library containing definition of pow" >&2;}
6825   fi
6826  
6827 <                        { echo "$as_me:$LINENO: checking for main in -lgmpxx" >&5
12612 < echo $ECHO_N "checking for main in -lgmpxx... $ECHO_C" >&6; }
12613 < if test "${ac_cv_lib_gmpxx_main+set}" = set; then
12614 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12615 < else
12616 <  ac_check_lib_save_LIBS=$LIBS
12617 < LIBS="-lgmpxx  $LIBS"
12618 < cat >conftest.$ac_ext <<_ACEOF
12619 < /* confdefs.h.  */
12620 < _ACEOF
12621 < cat confdefs.h >>conftest.$ac_ext
12622 < cat >>conftest.$ac_ext <<_ACEOF
12623 < /* end confdefs.h.  */
6827 > fi
6828  
6829 + fi
6830  
6831 < #ifdef FC_DUMMY_MAIN
6832 < #ifndef FC_DUMMY_MAIN_EQ_F77
6833 < #  ifdef __cplusplus
6834 <     extern "C"
6835 < #  endif
6836 <   int FC_DUMMY_MAIN() { return 1; }
6837 < #endif
12633 < #endif
12634 < int
12635 < main ()
12636 < {
12637 < return main ();
12638 <  ;
12639 <  return 0;
12640 < }
6831 > for ac_func in floor getpagesize gettimeofday memset pow pstat_getdynamic pstat_getstatic select sqrt strcasecmp strchr strdup stricmp strncasecmp strnicmp strstr strtol sysmp getsysinfo sysctl table
6832 > do :
6833 >  as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh`
6834 > ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var"
6835 > if eval test \"x\$"$as_ac_var"\" = x"yes"; then :
6836 >  cat >>confdefs.h <<_ACEOF
6837 > #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1
6838   _ACEOF
12642 – rm -f conftest.$ac_objext conftest$ac_exeext
12643 – if { (ac_try="$ac_link"
12644 – case "(($ac_try" in
12645 –  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
12646 –  *) ac_try_echo=$ac_try;;
12647 – esac
12648 – eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
12649 –  (eval "$ac_link") 2>conftest.er1
12650 –  ac_status=$?
12651 –  grep -v '^ *+' conftest.er1 >conftest.err
12652 –  rm -f conftest.er1
12653 –  cat conftest.err >&5
12654 –  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12655 –  (exit $ac_status); } && {
12656 –         test -z "$ac_c_werror_flag" ||
12657 –         test ! -s conftest.err
12658 –       } && test -s conftest$ac_exeext &&
12659 –       $as_test_x conftest$ac_exeext; then
12660 –  ac_cv_lib_gmpxx_main=yes
12661 – else
12662 –  echo "$as_me: failed program was:" >&5
12663 – sed 's/^/| /' conftest.$ac_ext >&5
6839  
12665 –        ac_cv_lib_gmpxx_main=no
6840   fi
6841 + done
6842  
12668 – rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
12669 –      conftest$ac_exeext conftest.$ac_ext
12670 – LIBS=$ac_check_lib_save_LIBS
12671 – fi
12672 – { echo "$as_me:$LINENO: result: $ac_cv_lib_gmpxx_main" >&5
12673 – echo "${ECHO_T}$ac_cv_lib_gmpxx_main" >&6; }
12674 – if test $ac_cv_lib_gmpxx_main = yes; then
12675 –  CGAL_LIBS="$CGAL_LIBS -lgmpxx"
12676 – fi
6843  
6844 <                fi
6845 <
6846 <                if test "$cgal_have_lib" == yes; then
6847 <                        acx_cgal_found=yes
6848 <                fi
12683 <        fi
12684 <        if test "$acx_cgal_found" == yes; then
12685 <                { echo "$as_me:$LINENO: checking for main in -lCore" >&5
12686 < echo $ECHO_N "checking for main in -lCore... $ECHO_C" >&6; }
12687 < if test "${ac_cv_lib_Core_main+set}" = set; then
12688 <  echo $ECHO_N "(cached) $ECHO_C" >&6
12689 < else
12690 <  ac_check_lib_save_LIBS=$LIBS
12691 < LIBS="-lCore  $LIBS"
12692 < cat >conftest.$ac_ext <<_ACEOF
12693 < /* confdefs.h.  */
12694 < _ACEOF
12695 < cat confdefs.h >>conftest.$ac_ext
12696 < cat >>conftest.$ac_ext <<_ACEOF
6844 > # special check for _system_configuration because AIX <4.3.2 do not
6845 > # contain the `physmem' member.
6846 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for external symbol _system_configuration" >&5
6847 > $as_echo_n "checking for external symbol _system_configuration... " >&6; }
6848 > cat confdefs.h - <<_ACEOF >conftest.$ac_ext
6849   /* end confdefs.h.  */
6850 <
12699 <
12700 < #ifdef FC_DUMMY_MAIN
12701 < #ifndef FC_DUMMY_MAIN_EQ_F77
12702 < #  ifdef __cplusplus
12703 <     extern "C"
12704 < #  endif
12705 <   int FC_DUMMY_MAIN() { return 1; }
12706 < #endif
12707 < #endif
6850 > #include <sys/systemcfg.h>
6851   int
6852   main ()
6853   {
6854 < return main ();
6854 > double x = _system_configuration.physmem;
6855    ;
6856    return 0;
6857   }
6858   _ACEOF
6859 < rm -f conftest.$ac_objext conftest$ac_exeext
6860 < if { (ac_try="$ac_link"
6861 < case "(($ac_try" in
6862 <  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
6863 <  *) ac_try_echo=$ac_try;;
6864 < esac
6865 < eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5
6866 <  (eval "$ac_link") 2>conftest.er1
6859 > if ac_fn_c_try_compile "$LINENO"; then :
6860 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
6861 > $as_echo "yes" >&6; }
6862 >
6863 > $as_echo "#define HAVE__SYSTEM_CONFIGURATION 1" >>confdefs.h
6864 >
6865 > else
6866 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
6867 > $as_echo "no" >&6; }
6868 > fi
6869 > rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
6870 >
6871 >
6872 > case $debug in
6873 >  1)
6874 >     ;;
6875 >  *)
6876 >
6877 >
6878 >
6879 >
6880 >
6881 >
6882 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU cc" >&5
6883 > $as_echo_n "checking whether we are *really* using GNU cc... " >&6; }
6884 > if ${ac_cv_prog_really_gcc+:} false; then :
6885 >  $as_echo_n "(cached) " >&6
6886 > else
6887 >
6888 > cat > conftest.c <<EOF
6889 > #ifdef __GNUC__
6890 >  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
6891 >     no;
6892 >  #else
6893 >     yes;
6894 >  #endif
6895 > #endif
6896 > EOF
6897 > if { ac_try='${CC-cc} -E conftest.c'
6898 >  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
6899 >  (eval $ac_try) 2>&5
6900    ac_status=$?
6901 <  grep -v '^ *+' conftest.er1 >conftest.err
6902 <  rm -f conftest.er1
6903 <  cat conftest.err >&5
12728 <  echo "$as_me:$LINENO: \$? = $ac_status" >&5
12729 <  (exit $ac_status); } && {
12730 <         test -z "$ac_c_werror_flag" ||
12731 <         test ! -s conftest.err
12732 <       } && test -s conftest$ac_exeext &&
12733 <       $as_test_x conftest$ac_exeext; then
12734 <  ac_cv_lib_Core_main=yes
6901 >  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
6902 >  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
6903 >  ac_cv_prog_really_gcc=yes
6904   else
6905 <  echo "$as_me: failed program was:" >&5
6906 < sed 's/^/| /' conftest.$ac_ext >&5
6905 >  ac_cv_prog_really_gcc=no
6906 > fi
6907  
12739 –        ac_cv_lib_Core_main=no
6908   fi
6909 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gcc" >&5
6910 + $as_echo "$ac_cv_prog_really_gcc" >&6; }
6911 + if test "$ac_cv_prog_really_gcc" = yes; then
6912 +        :
6913  
6914 < rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \
6915 <      conftest$ac_exeext conftest.$ac_ext
6916 < LIBS=$ac_check_lib_save_LIBS
6914 > else
6915 >        :
6916 >
6917   fi
6918 < { echo "$as_me:$LINENO: result: $ac_cv_lib_Core_main" >&5
6919 < echo "${ECHO_T}$ac_cv_lib_Core_main" >&6; }
6920 < if test $ac_cv_lib_Core_main = yes; then
6921 <  CGAL_LIBS="$CGAL_LIBS -lCore"
6918 >
6919 >
6920 > # Try to determine "good" native compiler flags if none specified on command
6921 > # line
6922 > if test "$ac_test_CFLAGS" != "set"; then
6923 >  CFLAGS=""
6924 >  case "${host_cpu}-${host_os}" in
6925 >
6926 >  *linux*) if test "$CC" = icc; then
6927 >                    CFLAGS="-O2"
6928 >                fi;;
6929 >  sparc-solaris2*) if test "$CC" = cc; then
6930 >                    CFLAGS="-O -dalign"
6931 >                 fi;;
6932 >
6933 >  alpha*-osf*)  if test "$CC" = cc; then
6934 >                    CFLAGS="-newc -w0 -O5 -ansi_alias -ansi_args -fp_reorder -tune host -arch host -std1"
6935 >                fi;;
6936 >
6937 >  hppa*-hpux*)  if test "$CC" = cc; then
6938 >                    CFLAGS="-Ae +O3 +Oall"
6939 >                fi;;
6940 >
6941 >   rs6000*-aix*)  if test "$CC" = cc -o "$CC" = xlc; then
6942 >                    CFLAGS="-O3 -qtune=auto -qansialias -w"
6943 >                fi;;
6944 >   powerpc*-aix*)
6945 >        if test "$CC" = cc -o "$CC" = xlc; then
6946 >                CFLAGS="-O3 -qtune=auto -qansialias -w"
6947 >                echo "*******************************************************"
6948 >                echo "*  You have AIX on an unknown powerpc system.  It is  *"
6949 >                echo "*  recommended that you use                           *"
6950 >                echo "*                                                     *"
6951 >                echo "*    CFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
6952 >                echo "*                                 ^^^                 *"
6953 >                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
6954 >                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
6955 >                echo "*******************************************************"
6956 >        fi;;
6957 >   *darwin*)
6958 >        if test "$CC" = xlc; then
6959 >                CFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
6960 >        fi
6961 >        if test "$CC" = icc; then
6962 >                CFLAGS="-O2"
6963 >        fi
6964 >        if test $ac_cv_prog_really_gcc = yes; then
6965 >                CFLAGS="-Os"
6966 >        fi;;
6967 >  esac
6968 >
6969 >  # use default flags for gcc on all systems
6970 >  if test $ac_cv_prog_really_gcc = yes -a -z "$CFLAGS"; then
6971 >     CFLAGS="-O2"
6972 >  fi
6973 >
6974 >  if test -z "$CFLAGS"; then
6975 >        echo ""
6976 >        echo "********************************************************"
6977 >        echo "* WARNING: Don't know the best CFLAGS for this system  *"
6978 >        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
6979 >        echo "* (otherwise, a default of CFLAGS=-O will be used)     *"
6980 >        echo "********************************************************"
6981 >        echo ""
6982 >        CFLAGS="-O"
6983 >  fi
6984 >
6985 >
6986 >
6987 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC} accepts ${CFLAGS}" >&5
6988 > $as_echo_n "checking whether ${CC} accepts ${CFLAGS}... " >&6; }
6989 > if ${ac_cv_ac_cv_guessed_cflags+:} false; then :
6990 >  $as_echo_n "(cached) " >&6
6991 > else
6992 >  echo 'void f(){}' > conftest.c
6993 > if test -z "`${CC} ${CFLAGS} -c conftest.c 2>&1`"; then
6994 >        ac_cv_ac_cv_guessed_cflags=yes
6995 > else
6996 >        ac_cv_ac_cv_guessed_cflags=no
6997   fi
6998 + rm -f conftest*
6999  
12752 –        fi
7000   fi
7001 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cflags" >&5
7002 + $as_echo "$ac_cv_ac_cv_guessed_cflags" >&6; }
7003 + if test "$ac_cv_ac_cv_guessed_cflags" = yes; then
7004 +        :
7005  
7006 + else
7007 +        :
7008  
7009 +        echo ""
7010 +        echo "********************************************************"
7011 +        echo "* WARNING: The guessed CFLAGS don't seem to work with  *"
7012 +        echo "* your compiler.                                       *"
7013 +        echo "* Use  make CFLAGS=..., or edit the top level Makefile *"
7014 +        echo "********************************************************"
7015 +        echo ""
7016 +        CFLAGS=""
7017  
7018 < { echo "$as_me:$LINENO: checking CGAL" >&5
12758 < echo $ECHO_N "checking CGAL... $ECHO_C" >&6; }
7018 > fi
7019  
7020  
7021 + fi
7022  
7023  
7024  
12764 – if test "$acx_cgal_found" == yes; then
12765 –        { echo "$as_me:$LINENO: result: yes" >&5
12766 – echo "${ECHO_T}yes" >&6; }
7025  
7026 +
7027 +
7028 +
7029 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are *really* using GNU c++" >&5
7030 + $as_echo_n "checking whether we are *really* using GNU c++... " >&6; }
7031 + if ${ac_cv_prog_really_gxx+:} false; then :
7032 +  $as_echo_n "(cached) " >&6
7033   else
12769 –        { echo "$as_me:$LINENO: result: no" >&5
12770 – echo "${ECHO_T}no" >&6; }
7034  
7035 + cat > conftest.cpp <<EOF
7036 + #ifdef __GNUC__
7037 +  #if defined(__INTEL_COMPILER) || defined(__PATHCC__)
7038 +     no;
7039 +  #else
7040 +     yes;
7041 +  #endif
7042 + #endif
7043 + EOF
7044 + if { ac_try='${CXX-c++} -E conftest.cpp'
7045 +  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
7046 +  (eval $ac_try) 2>&5
7047 +  ac_status=$?
7048 +  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
7049 +  test $ac_status = 0; }; } | egrep yes >/dev/null 2>&1; then
7050 +  ac_cv_prog_really_gxx=yes
7051 + else
7052 +  ac_cv_prog_really_gxx=no
7053   fi
12773 – USE_CGAL=no
12774 – if test "$acx_cgal_found" == yes; then
12775 –        USE_CGAL=yes
7054  
7055 < cat >>confdefs.h <<\_ACEOF
7056 < #define HAVE_CGAL 1
7057 < _ACEOF
7055 > fi
7056 > { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_really_gxx" >&5
7057 > $as_echo "$ac_cv_prog_really_gxx" >&6; }
7058 > if test "$ac_cv_prog_really_gxx" = yes; then
7059 >        :
7060  
7061 + else
7062 +        :
7063  
7064 + fi
7065  
7066  
7067 + # Try to determine "good" native compiler flags if none specified on command
7068 + # line
7069 + if test "$ac_test_CXXFLAGS" != "set"; then
7070 +  CXXFLAGS=""
7071 +  case "${host_cpu}-${host_os}" in
7072  
7073 +  *linux*) if test "$CXX" = icc -o "$CXX" = icpc; then
7074 +                    CXXFLAGS="-O2"
7075 +                fi;;
7076 +  sparc-solaris2*) if test "$CXX" = CC; then
7077 +                    CXXFLAGS="-features=extensions -O -dalign"
7078 +                 fi;;
7079 +   rs6000*-aix*)  if test "$CXX" = xlC; then
7080 +                    CXXFLAGS="-O3 -qarch=pwrx -qtune=pwrx -qansialias -w"
7081 +                fi;;
7082 +   powerpc*-aix*)
7083 +        if test "$CXX" = xlC; then
7084 +                CXXFLAGS="-O3 -qarch=ppc -qansialias -w"
7085 +                echo "*******************************************************"
7086 +                echo "*  You have AIX on an unknown powerpc system.  It is  *"
7087 +                echo "*  recommended that you use                           *"
7088 +                echo "*                                                     *"
7089 +                echo "*  CXXFLAGS=-O3 -qarch=ppc -qtune=xxx -qansialias -w  *"
7090 +                echo "*                                 ^^^                 *"
7091 +                echo "*  where xxx is 601, 603, 604, or whatever kind of    *"
7092 +                echo "*  PowerPC CPU you have.   For more info, man cc.     *"
7093 +                echo "*******************************************************"
7094 +        fi;;
7095 +   *darwin*)
7096 +        if test "$CXX" = xlc++ -o "$CXX" = xlC ; then
7097 +                CXXFLAGS="-qthreaded -O -qtune=auto -qarch=auto -qunroll=auto -qaltivec"
7098 +        fi
7099 +        if test "$CXX" = icpc; then
7100 +                CXXFLAGS="-O2"
7101 +        fi
7102 +        if test $ac_cv_prog_really_gxx = yes; then
7103 +                CXXFLAGS="-Os"
7104 +        fi;;
7105 +  esac
7106 +
7107 +  # use default flags for gcc on all systems
7108 +  if test $ac_cv_prog_really_gxx = yes -a -z "$CXXFLAGS"; then
7109 +     CXXFLAGS="-O2"
7110 +  fi
7111 +
7112 +  if test -z "$CXXFLAGS"; then
7113 +        echo ""
7114 +        echo "**********************************************************"
7115 +        echo "* WARNING: Don't know the best CXXFLAGS for this system  *"
7116 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7117 +        echo "* (otherwise, a default of CXXFLAGS=-O will be used)     *"
7118 +        echo "**********************************************************"
7119 +        echo ""
7120 +        CXXFLAGS="-O"
7121 +  fi
7122 +
7123 +
7124 +
7125 + { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CXX} accepts ${CXXFLAGS}" >&5
7126 + $as_echo_n "checking whether ${CXX} accepts ${CXXFLAGS}... " >&6; }
7127 + if ${ac_cv_ac_cv_guessed_cxxflags+:} false; then :
7128 +  $as_echo_n "(cached) " >&6
7129 + else
7130 +  echo 'void f(){}' > conftest.cpp
7131 + if test -z "`${CXX} ${CXXFLAGS} -c conftest.cpp 2>&1`"; then
7132 +        ac_cv_ac_cv_guessed_cxxflags=yes
7133 + else
7134 +        ac_cv_ac_cv_guessed_cxxflags=no
7135   fi
7136 + rm -f conftest*
7137  
7138 + fi
7139 + { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_ac_cv_guessed_cxxflags" >&5
7140 + $as_echo "$ac_cv_ac_cv_guessed_cxxflags" >&6; }
7141 + if test "$ac_cv_ac_cv_guessed_cxxflags" = yes; then
7142 +        :
7143  
7144 + else
7145 +        :
7146  
7147 +        echo ""
7148 +        echo "**********************************************************"
7149 +        echo "* WARNING: The guessed CXXFLAGS don't seem to work with  *"
7150 +        echo "* your compiler.                                         *"
7151 +        echo "* Use  make CXXFLAGS=..., or edit the top level Makefile *"
7152 +        echo "**********************************************************"
7153 +        echo ""
7154 +        CXXFLAGS=""
7155  
7156 + fi
7157 +
7158 +
7159 + fi
7160 +
7161 +     ;;
7162 + esac
7163 +
7164 +
7165   # Check whether --enable-doxygen was given.
7166 < if test "${enable_doxygen+set}" = set; then
7166 > if test "${enable_doxygen+set}" = set; then :
7167    enableval=$enable_doxygen;
7168   fi
7169  
7170   # Check whether --enable-dot was given.
7171 < if test "${enable_dot+set}" = set; then
7171 > if test "${enable_dot+set}" = set; then :
7172    enableval=$enable_dot;
7173   fi
7174  
7175   # Check whether --enable-html-docs was given.
7176 < if test "${enable_html_docs+set}" = set; then
7176 > if test "${enable_html_docs+set}" = set; then :
7177    enableval=$enable_html_docs;
7178   else
7179     enable_html_docs=yes
7180   fi
7181  
7182   # Check whether --enable-latex-docs was given.
7183 < if test "${enable_latex_docs+set}" = set; then
7183 > if test "${enable_latex_docs+set}" = set; then :
7184    enableval=$enable_latex_docs;
7185   else
7186     enable_latex_docs=no
# Line 12816 | Line 7191 | set dummy doxygen; ac_word=$2
7191   else
7192          # Extract the first word of "doxygen", so it can be a program name with args.
7193   set dummy doxygen; ac_word=$2
7194 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
7195 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
7196 < if test "${ac_cv_path_DOXYGEN+set}" = set; then
7197 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7194 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7195 > $as_echo_n "checking for $ac_word... " >&6; }
7196 > if ${ac_cv_path_DOXYGEN+:} false; then :
7197 >  $as_echo_n "(cached) " >&6
7198   else
7199    case $DOXYGEN in
7200    [\\/]* | ?:[\\/]*)
# Line 12831 | Line 7206 | do
7206   do
7207    IFS=$as_save_IFS
7208    test -z "$as_dir" && as_dir=.
7209 <  for ac_exec_ext in '' $ac_executable_extensions; do
7209 >    for ac_exec_ext in '' $ac_executable_extensions; do
7210    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7211      ac_cv_path_DOXYGEN="$as_dir/$ac_word$ac_exec_ext"
7212 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7212 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7213      break 2
7214    fi
7215   done
7216 < done
7216 >  done
7217   IFS=$as_save_IFS
7218  
7219    ;;
# Line 12846 | Line 7221 | if test -n "$DOXYGEN"; then
7221   fi
7222   DOXYGEN=$ac_cv_path_DOXYGEN
7223   if test -n "$DOXYGEN"; then
7224 <  { echo "$as_me:$LINENO: result: $DOXYGEN" >&5
7225 < echo "${ECHO_T}$DOXYGEN" >&6; }
7224 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOXYGEN" >&5
7225 > $as_echo "$DOXYGEN" >&6; }
7226   else
7227 <  { echo "$as_me:$LINENO: result: no" >&5
7228 < echo "${ECHO_T}no" >&6; }
7227 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7228 > $as_echo "no" >&6; }
7229   fi
7230  
7231  
7232          if test "x$DOXYGEN" = x; then
7233                  if test "x$enable_doxygen" = xyes; then
7234 <                        { { echo "$as_me:$LINENO: error: could not find doxygen" >&5
12860 < echo "$as_me: error: could not find doxygen" >&2;}
12861 <   { (exit 1); exit 1; }; }
7234 >                        as_fn_error $? "could not find doxygen" "$LINENO" 5
7235                  fi
7236                  enable_doc=no
7237          else
7238                  enable_doc=yes
7239                  # Extract the first word of "dot", so it can be a program name with args.
7240   set dummy dot; ac_word=$2
7241 < { echo "$as_me:$LINENO: checking for $ac_word" >&5
7242 < echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; }
7243 < if test "${ac_cv_path_DOT+set}" = set; then
7244 <  echo $ECHO_N "(cached) $ECHO_C" >&6
7241 > { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
7242 > $as_echo_n "checking for $ac_word... " >&6; }
7243 > if ${ac_cv_path_DOT+:} false; then :
7244 >  $as_echo_n "(cached) " >&6
7245   else
7246    case $DOT in
7247    [\\/]* | ?:[\\/]*)
# Line 12880 | Line 7253 | do
7253   do
7254    IFS=$as_save_IFS
7255    test -z "$as_dir" && as_dir=.
7256 <  for ac_exec_ext in '' $ac_executable_extensions; do
7256 >    for ac_exec_ext in '' $ac_executable_extensions; do
7257    if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
7258      ac_cv_path_DOT="$as_dir/$ac_word$ac_exec_ext"
7259 <    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7259 >    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
7260      break 2
7261    fi
7262   done
7263 < done
7263 >  done
7264   IFS=$as_save_IFS
7265  
7266    ;;
# Line 12895 | Line 7268 | if test -n "$DOT"; then
7268   fi
7269   DOT=$ac_cv_path_DOT
7270   if test -n "$DOT"; then
7271 <  { echo "$as_me:$LINENO: result: $DOT" >&5
7272 < echo "${ECHO_T}$DOT" >&6; }
7271 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DOT" >&5
7272 > $as_echo "$DOT" >&6; }
7273   else
7274 <  { echo "$as_me:$LINENO: result: no" >&5
7275 < echo "${ECHO_T}no" >&6; }
7274 >  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
7275 > $as_echo "no" >&6; }
7276   fi
7277  
7278  
# Line 12915 | Line 7288 | if test x$DOT = x; then
7288  
7289   if test x$DOT = x; then
7290          if test "x$enable_dot" = xyes; then
7291 <                { { echo "$as_me:$LINENO: error: could not find dot" >&5
12919 < echo "$as_me: error: could not find dot" >&2;}
12920 <   { (exit 1); exit 1; }; }
7291 >                as_fn_error $? "could not find dot" "$LINENO" 5
7292          fi
7293          enable_dot=no
7294   else
# Line 12939 | Line 7310 | fi
7310  
7311  
7312  
12942 –
12943 –
12944 –
7313   ac_config_files="$ac_config_files make/Makefile src/utils/Makefile src/math/Makefile src/integrators/Makefile src/applications/atom2md/Makefile scripts/filepp"
7314  
7315  
# Line 12972 | Line 7340 | _ACEOF
7340      case $ac_val in #(
7341      *${as_nl}*)
7342        case $ac_var in #(
7343 <      *_cv_*) { echo "$as_me:$LINENO: WARNING: Cache variable $ac_var contains a newline." >&5
7344 < echo "$as_me: WARNING: Cache variable $ac_var contains a newline." >&2;} ;;
7343 >      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
7344 > $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
7345        esac
7346        case $ac_var in #(
7347        _ | IFS | as_nl) ;; #(
7348 <      *) $as_unset $ac_var ;;
7348 >      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
7349 >      *) { eval $ac_var=; unset $ac_var;} ;;
7350        esac ;;
7351      esac
7352    done
# Line 12985 | Line 7354 | echo "$as_me: WARNING: Cache variable $ac_var contains
7354    (set) 2>&1 |
7355      case $as_nl`(ac_space=' '; set) 2>&1` in #(
7356      *${as_nl}ac_space=\ *)
7357 <      # `set' does not quote correctly, so add quotes (double-quote
7358 <      # substitution turns \\\\ into \\, and sed turns \\ into \).
7357 >      # `set' does not quote correctly, so add quotes: double-quote
7358 >      # substitution turns \\\\ into \\, and sed turns \\ into \.
7359        sed -n \
7360          "s/'/'\\\\''/g;
7361            s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
# Line 13008 | Line 7377 | if diff "$cache_file" confcache >/dev/null 2>&1; then
7377       :end' >>confcache
7378   if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
7379    if test -w "$cache_file"; then
7380 <    test "x$cache_file" != "x/dev/null" &&
7381 <      { echo "$as_me:$LINENO: updating cache $cache_file" >&5
7382 < echo "$as_me: updating cache $cache_file" >&6;}
7383 <    cat confcache >$cache_file
7380 >    if test "x$cache_file" != "x/dev/null"; then
7381 >      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
7382 > $as_echo "$as_me: updating cache $cache_file" >&6;}
7383 >      if test ! -f "$cache_file" || test -h "$cache_file"; then
7384 >        cat confcache >"$cache_file"
7385 >      else
7386 >        case $cache_file in #(
7387 >        */* | ?:*)
7388 >          mv -f confcache "$cache_file"$$ &&
7389 >          mv -f "$cache_file"$$ "$cache_file" ;; #(
7390 >        *)
7391 >          mv -f confcache "$cache_file" ;;
7392 >        esac
7393 >      fi
7394 >    fi
7395    else
7396 <    { echo "$as_me:$LINENO: not updating unwritable cache $cache_file" >&5
7397 < echo "$as_me: not updating unwritable cache $cache_file" >&6;}
7396 >    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
7397 > $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
7398    fi
7399   fi
7400   rm -f confcache
# Line 13027 | Line 7407 | ac_ltlibobjs=
7407  
7408   ac_libobjs=
7409   ac_ltlibobjs=
7410 + U=
7411   for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
7412    # 1. Remove the extension, and $U if already installed.
7413    ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
7414 <  ac_i=`echo "$ac_i" | sed "$ac_script"`
7414 >  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
7415    # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
7416    #    will be set to the directory where LIBOBJS objects are built.
7417 <  ac_libobjs="$ac_libobjs \${LIBOBJDIR}$ac_i\$U.$ac_objext"
7418 <  ac_ltlibobjs="$ac_ltlibobjs \${LIBOBJDIR}$ac_i"'$U.lo'
7417 >  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
7418 >  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
7419   done
7420   LIBOBJS=$ac_libobjs
7421  
# Line 13042 | Line 7423 | LTLIBOBJS=$ac_ltlibobjs
7423  
7424  
7425  
7426 < : ${CONFIG_STATUS=./config.status}
7426 > : "${CONFIG_STATUS=./config.status}"
7427 > ac_write_fail=0
7428   ac_clean_files_save=$ac_clean_files
7429   ac_clean_files="$ac_clean_files $CONFIG_STATUS"
7430 < { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
7431 < echo "$as_me: creating $CONFIG_STATUS" >&6;}
7432 < cat >$CONFIG_STATUS <<_ACEOF
7430 > { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
7431 > $as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
7432 > as_write_fail=0
7433 > cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
7434   #! $SHELL
7435   # Generated by $as_me.
7436   # Run this file to recreate the current configuration.
# Line 13057 | Line 7440 | ac_cs_silent=false
7440   debug=false
7441   ac_cs_recheck=false
7442   ac_cs_silent=false
7443 +
7444   SHELL=\${CONFIG_SHELL-$SHELL}
7445 < _ACEOF
7445 > export SHELL
7446 > _ASEOF
7447 > cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
7448 > ## -------------------- ##
7449 > ## M4sh Initialization. ##
7450 > ## -------------------- ##
7451  
13063 – cat >>$CONFIG_STATUS <<\_ACEOF
13064 – ## --------------------- ##
13065 – ## M4sh Initialization.  ##
13066 – ## --------------------- ##
13067 –
7452   # Be more Bourne compatible
7453   DUALCASE=1; export DUALCASE # for MKS sh
7454 < if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
7454 > if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
7455    emulate sh
7456    NULLCMD=:
7457 <  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
7457 >  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
7458    # is contrary to our usage.  Disable this feature.
7459    alias -g '${1+"$@"}'='"$@"'
7460    setopt NO_GLOB_SUBST
7461   else
7462 <  case `(set -o) 2>/dev/null` in
7463 <  *posix*) set -o posix ;;
7462 >  case `(set -o) 2>/dev/null` in #(
7463 >  *posix*) :
7464 >    set -o posix ;; #(
7465 >  *) :
7466 >     ;;
7467   esac
13081 –
7468   fi
7469  
7470  
7471 <
7472 <
7473 < # PATH needs CR
7474 < # Avoid depending upon Character Ranges.
7475 < as_cr_letters='abcdefghijklmnopqrstuvwxyz'
7476 < as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
7477 < as_cr_Letters=$as_cr_letters$as_cr_LETTERS
7478 < as_cr_digits='0123456789'
7479 < as_cr_alnum=$as_cr_Letters$as_cr_digits
7480 <
7481 < # The user is always right.
7482 < if test "${PATH_SEPARATOR+set}" != set; then
7483 <  echo "#! /bin/sh" >conf$$.sh
7484 <  echo  "exit 0"   >>conf$$.sh
7485 <  chmod +x conf$$.sh
7486 <  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
7487 <    PATH_SEPARATOR=';'
7471 > as_nl='
7472 > '
7473 > export as_nl
7474 > # Printing a long string crashes Solaris 7 /usr/bin/printf.
7475 > as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
7476 > as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
7477 > as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
7478 > # Prefer a ksh shell builtin over an external printf program on Solaris,
7479 > # but without wasting forks for bash or zsh.
7480 > if test -z "$BASH_VERSION$ZSH_VERSION" \
7481 >    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
7482 >  as_echo='print -r --'
7483 >  as_echo_n='print -rn --'
7484 > elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
7485 >  as_echo='printf %s\n'
7486 >  as_echo_n='printf %s'
7487 > else
7488 >  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
7489 >    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
7490 >    as_echo_n='/usr/ucb/echo -n'
7491    else
7492 <    PATH_SEPARATOR=:
7492 >    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
7493 >    as_echo_n_body='eval
7494 >      arg=$1;
7495 >      case $arg in #(
7496 >      *"$as_nl"*)
7497 >        expr "X$arg" : "X\\(.*\\)$as_nl";
7498 >        arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
7499 >      esac;
7500 >      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
7501 >    '
7502 >    export as_echo_n_body
7503 >    as_echo_n='sh -c $as_echo_n_body as_echo'
7504    fi
7505 <  rm -f conf$$.sh
7505 >  export as_echo_body
7506 >  as_echo='sh -c $as_echo_body as_echo'
7507   fi
7508  
7509 < # Support unset when possible.
7510 < if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
7511 <  as_unset=unset
7512 < else
7513 <  as_unset=false
7509 > # The user is always right.
7510 > if test "${PATH_SEPARATOR+set}" != set; then
7511 >  PATH_SEPARATOR=:
7512 >  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
7513 >    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
7514 >      PATH_SEPARATOR=';'
7515 >  }
7516   fi
7517  
7518  
# Line 13118 | Line 7521 | fi
7521   # there to prevent editors from complaining about space-tab.
7522   # (If _AS_PATH_WALK were called with IFS unset, it would disable word
7523   # splitting by setting IFS to empty value.)
13121 – as_nl='
13122 – '
7524   IFS=" ""        $as_nl"
7525  
7526   # Find who we are.  Look in the path if we contain no directory separator.
7527 < case $0 in
7527 > as_myself=
7528 > case $0 in #((
7529    *[\\/]* ) as_myself=$0 ;;
7530    *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7531   for as_dir in $PATH
7532   do
7533    IFS=$as_save_IFS
7534    test -z "$as_dir" && as_dir=.
7535 <  test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7536 < done
7535 >    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
7536 >  done
7537   IFS=$as_save_IFS
7538  
7539       ;;
# Line 13142 | Line 7544 | if test ! -f "$as_myself"; then
7544    as_myself=$0
7545   fi
7546   if test ! -f "$as_myself"; then
7547 <  echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
7548 <  { (exit 1); exit 1; }
7547 >  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
7548 >  exit 1
7549   fi
7550  
7551 < # Work around bugs in pre-3.0 UWIN ksh.
7552 < for as_var in ENV MAIL MAILPATH
7553 < do ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
7551 > # Unset variables that we do not need and which cause bugs (e.g. in
7552 > # pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
7553 > # suppresses any "Segmentation fault" message there.  '((' could
7554 > # trigger a bug in pdksh 5.2.14.
7555 > for as_var in BASH_ENV ENV MAIL MAILPATH
7556 > do eval test x\${$as_var+set} = xset \
7557 >  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
7558   done
7559   PS1='$ '
7560   PS2='> '
7561   PS4='+ '
7562  
7563   # NLS nuisances.
7564 < for as_var in \
7565 <  LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
7566 <  LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
7567 <  LC_TELEPHONE LC_TIME
7568 < do
7569 <  if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
7570 <    eval $as_var=C; export $as_var
7571 <  else
7572 <    ($as_unset $as_var) >/dev/null 2>&1 && $as_unset $as_var
7564 > LC_ALL=C
7565 > export LC_ALL
7566 > LANGUAGE=C
7567 > export LANGUAGE
7568 >
7569 > # CDPATH.
7570 > (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
7571 >
7572 >
7573 > # as_fn_error STATUS ERROR [LINENO LOG_FD]
7574 > # ----------------------------------------
7575 > # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
7576 > # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
7577 > # script with STATUS, using 1 if that was 0.
7578 > as_fn_error ()
7579 > {
7580 >  as_status=$1; test $as_status -eq 0 && as_status=1
7581 >  if test "$4"; then
7582 >    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
7583 >    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
7584    fi
7585 < done
7585 >  $as_echo "$as_me: error: $2" >&2
7586 >  as_fn_exit $as_status
7587 > } # as_fn_error
7588  
7589 < # Required to use basename.
7589 >
7590 > # as_fn_set_status STATUS
7591 > # -----------------------
7592 > # Set $? to STATUS, without forking.
7593 > as_fn_set_status ()
7594 > {
7595 >  return $1
7596 > } # as_fn_set_status
7597 >
7598 > # as_fn_exit STATUS
7599 > # -----------------
7600 > # Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
7601 > as_fn_exit ()
7602 > {
7603 >  set +e
7604 >  as_fn_set_status $1
7605 >  exit $1
7606 > } # as_fn_exit
7607 >
7608 > # as_fn_unset VAR
7609 > # ---------------
7610 > # Portably unset VAR.
7611 > as_fn_unset ()
7612 > {
7613 >  { eval $1=; unset $1;}
7614 > }
7615 > as_unset=as_fn_unset
7616 > # as_fn_append VAR VALUE
7617 > # ----------------------
7618 > # Append the text in VALUE to the end of the definition contained in VAR. Take
7619 > # advantage of any shell optimizations that allow amortized linear growth over
7620 > # repeated appends, instead of the typical quadratic growth present in naive
7621 > # implementations.
7622 > if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
7623 >  eval 'as_fn_append ()
7624 >  {
7625 >    eval $1+=\$2
7626 >  }'
7627 > else
7628 >  as_fn_append ()
7629 >  {
7630 >    eval $1=\$$1\$2
7631 >  }
7632 > fi # as_fn_append
7633 >
7634 > # as_fn_arith ARG...
7635 > # ------------------
7636 > # Perform arithmetic evaluation on the ARGs, and store the result in the
7637 > # global $as_val. Take advantage of shells that can avoid forks. The arguments
7638 > # must be portable across $(()) and expr.
7639 > if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
7640 >  eval 'as_fn_arith ()
7641 >  {
7642 >    as_val=$(( $* ))
7643 >  }'
7644 > else
7645 >  as_fn_arith ()
7646 >  {
7647 >    as_val=`expr "$@" || test $? -eq 1`
7648 >  }
7649 > fi # as_fn_arith
7650 >
7651 >
7652   if expr a : '\(a\)' >/dev/null 2>&1 &&
7653     test "X`expr 00001 : '.*\(...\)'`" = X001; then
7654    as_expr=expr
# Line 13181 | Line 7662 | fi
7662    as_basename=false
7663   fi
7664  
7665 + if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
7666 +  as_dirname=dirname
7667 + else
7668 +  as_dirname=false
7669 + fi
7670  
13185 – # Name of the executable.
7671   as_me=`$as_basename -- "$0" ||
7672   $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
7673           X"$0" : 'X\(//\)$' \| \
7674           X"$0" : 'X\(/\)' \| . 2>/dev/null ||
7675 < echo X/"$0" |
7675 > $as_echo X/"$0" |
7676      sed '/^.*\/\([^/][^/]*\)\/*$/{
7677              s//\1/
7678              q
# Line 13202 | Line 7687 | echo X/"$0" |
7687            }
7688            s/.*/./; q'`
7689  
7690 < # CDPATH.
7691 < $as_unset CDPATH
7692 <
7693 <
7694 <
7695 <  as_lineno_1=$LINENO
13211 <  as_lineno_2=$LINENO
13212 <  test "x$as_lineno_1" != "x$as_lineno_2" &&
13213 <  test "x`expr $as_lineno_1 + 1`" = "x$as_lineno_2" || {
13214 <
13215 <  # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13216 <  # uniformly replaced by the line number.  The first 'sed' inserts a
13217 <  # line-number line after each line using $LINENO; the second 'sed'
13218 <  # does the real work.  The second script uses 'N' to pair each
13219 <  # line-number line with the line containing $LINENO, and appends
13220 <  # trailing '-' during substitution so that $LINENO is not a special
13221 <  # case at line end.
13222 <  # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13223 <  # scripts with optimization help from Paolo Bonzini.  Blame Lee
13224 <  # E. McMahon (1931-1989) for sed's syntax.  :-)
13225 <  sed -n '
13226 <    p
13227 <    /[$]LINENO/=
13228 <  ' <$as_myself |
13229 <    sed '
13230 <      s/[$]LINENO.*/&-/
13231 <      t lineno
13232 <      b
13233 <      :lineno
13234 <      N
13235 <      :loop
13236 <      s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/
13237 <      t loop
13238 <      s/-\n.*//
13239 <    ' >$as_me.lineno &&
13240 <  chmod +x "$as_me.lineno" ||
13241 <    { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
13242 <   { (exit 1); exit 1; }; }
13243 <
13244 <  # Don't try to exec as it changes $[0], causing all sort of problems
13245 <  # (the dirname of $[0] is not the place where we might find the
13246 <  # original and so on.  Autoconf is especially sensitive to this).
13247 <  . "./$as_me.lineno"
13248 <  # Exit status is that of the last command.
13249 <  exit
13250 < }
7690 > # Avoid depending upon Character Ranges.
7691 > as_cr_letters='abcdefghijklmnopqrstuvwxyz'
7692 > as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
7693 > as_cr_Letters=$as_cr_letters$as_cr_LETTERS
7694 > as_cr_digits='0123456789'
7695 > as_cr_alnum=$as_cr_Letters$as_cr_digits
7696  
13252 –
13253 – if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
13254 –  as_dirname=dirname
13255 – else
13256 –  as_dirname=false
13257 – fi
13258 –
7697   ECHO_C= ECHO_N= ECHO_T=
7698 < case `echo -n x` in
7698 > case `echo -n x` in #(((((
7699   -n*)
7700 <  case `echo 'x\c'` in
7700 >  case `echo 'xy\c'` in
7701    *c*) ECHO_T=' ';;     # ECHO_T is single tab character.
7702 <  *)   ECHO_C='\c';;
7702 >  xy)  ECHO_C='\c';;
7703 >  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
7704 >       ECHO_T=' ';;
7705    esac;;
7706   *)
7707    ECHO_N='-n';;
7708   esac
7709  
13270 – if expr a : '\(a\)' >/dev/null 2>&1 &&
13271 –   test "X`expr 00001 : '.*\(...\)'`" = X001; then
13272 –  as_expr=expr
13273 – else
13274 –  as_expr=false
13275 – fi
13276 –
7710   rm -f conf$$ conf$$.exe conf$$.file
7711   if test -d conf$$.dir; then
7712    rm -f conf$$.dir/conf$$.file
7713   else
7714    rm -f conf$$.dir
7715 <  mkdir conf$$.dir
7715 >  mkdir conf$$.dir 2>/dev/null
7716   fi
7717 < echo >conf$$.file
7718 < if ln -s conf$$.file conf$$ 2>/dev/null; then
7719 <  as_ln_s='ln -s'
7720 <  # ... but there are two gotchas:
7721 <  # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
7722 <  # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
7723 <  # In both cases, we have to default to `cp -p'.
7724 <  ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
7717 > if (echo >conf$$.file) 2>/dev/null; then
7718 >  if ln -s conf$$.file conf$$ 2>/dev/null; then
7719 >    as_ln_s='ln -s'
7720 >    # ... but there are two gotchas:
7721 >    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
7722 >    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
7723 >    # In both cases, we have to default to `cp -p'.
7724 >    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
7725 >      as_ln_s='cp -p'
7726 >  elif ln conf$$.file conf$$ 2>/dev/null; then
7727 >    as_ln_s=ln
7728 >  else
7729      as_ln_s='cp -p'
7730 < elif ln conf$$.file conf$$ 2>/dev/null; then
13294 <  as_ln_s=ln
7730 >  fi
7731   else
7732    as_ln_s='cp -p'
7733   fi
7734   rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
7735   rmdir conf$$.dir 2>/dev/null
7736  
7737 +
7738 + # as_fn_mkdir_p
7739 + # -------------
7740 + # Create "$as_dir" as a directory, including parents if necessary.
7741 + as_fn_mkdir_p ()
7742 + {
7743 +
7744 +  case $as_dir in #(
7745 +  -*) as_dir=./$as_dir;;
7746 +  esac
7747 +  test -d "$as_dir" || eval $as_mkdir_p || {
7748 +    as_dirs=
7749 +    while :; do
7750 +      case $as_dir in #(
7751 +      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
7752 +      *) as_qdir=$as_dir;;
7753 +      esac
7754 +      as_dirs="'$as_qdir' $as_dirs"
7755 +      as_dir=`$as_dirname -- "$as_dir" ||
7756 + $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
7757 +         X"$as_dir" : 'X\(//\)[^/]' \| \
7758 +         X"$as_dir" : 'X\(//\)$' \| \
7759 +         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
7760 + $as_echo X"$as_dir" |
7761 +    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
7762 +            s//\1/
7763 +            q
7764 +          }
7765 +          /^X\(\/\/\)[^/].*/{
7766 +            s//\1/
7767 +            q
7768 +          }
7769 +          /^X\(\/\/\)$/{
7770 +            s//\1/
7771 +            q
7772 +          }
7773 +          /^X\(\/\).*/{
7774 +            s//\1/
7775 +            q
7776 +          }
7777 +          s/.*/./; q'`
7778 +      test -d "$as_dir" && break
7779 +    done
7780 +    test -z "$as_dirs" || eval "mkdir $as_dirs"
7781 +  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
7782 +
7783 +
7784 + } # as_fn_mkdir_p
7785   if mkdir -p . 2>/dev/null; then
7786 <  as_mkdir_p=:
7786 >  as_mkdir_p='mkdir -p "$as_dir"'
7787   else
7788    test -d ./-p && rmdir ./-p
7789    as_mkdir_p=false
# Line 13316 | Line 7800 | else
7800    as_test_x='
7801      eval sh -c '\''
7802        if test -d "$1"; then
7803 <        test -d "$1/.";
7803 >        test -d "$1/.";
7804        else
7805 <        case $1 in
7806 <        -*)set "./$1";;
7805 >        case $1 in #(
7806 >        -*)set "./$1";;
7807          esac;
7808 <        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in
7808 >        case `ls -ld'$as_ls_L_option' "$1" 2>/dev/null` in #((
7809          ???[sx]*):;;*)false;;esac;fi
7810      '\'' sh
7811    '
# Line 13336 | Line 7820 | exec 6>&1
7820  
7821  
7822   exec 6>&1
7823 + ## ----------------------------------- ##
7824 + ## Main body of $CONFIG_STATUS script. ##
7825 + ## ----------------------------------- ##
7826 + _ASEOF
7827 + test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
7828  
7829 < # Save the log message, to keep $[0] and so on meaningful, and to
7829 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7830 > # Save the log message, to keep $0 and so on meaningful, and to
7831   # report actual input values of CONFIG_FILES etc. instead of their
7832   # values after options handling.
7833   ac_log="
7834 < This file was extended by OOPSE $as_me 4.0, which was
7835 < generated by GNU Autoconf 2.61.  Invocation command line was
7834 > This file was extended by OpenMD $as_me 1.0, which was
7835 > generated by GNU Autoconf 2.68.  Invocation command line was
7836  
7837    CONFIG_FILES    = $CONFIG_FILES
7838    CONFIG_HEADERS  = $CONFIG_HEADERS
# Line 13355 | Line 7845 | _ACEOF
7845  
7846   _ACEOF
7847  
7848 < cat >>$CONFIG_STATUS <<_ACEOF
7848 > case $ac_config_files in *"
7849 > "*) set x $ac_config_files; shift; ac_config_files=$*;;
7850 > esac
7851 >
7852 > case $ac_config_headers in *"
7853 > "*) set x $ac_config_headers; shift; ac_config_headers=$*;;
7854 > esac
7855 >
7856 >
7857 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7858   # Files that config.status was made for.
7859   config_files="$ac_config_files"
7860   config_headers="$ac_config_headers"
7861  
7862   _ACEOF
7863  
7864 < cat >>$CONFIG_STATUS <<\_ACEOF
7864 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7865   ac_cs_usage="\
7866 < \`$as_me' instantiates files from templates according to the
7867 < current configuration.
7866 > \`$as_me' instantiates files and other configuration actions
7867 > from templates according to the current configuration.  Unless the files
7868 > and actions are specified as TAGs, all are instantiated by default.
7869  
7870 < Usage: $0 [OPTIONS] [FILE]...
7870 > Usage: $0 [OPTION]... [TAG]...
7871  
7872    -h, --help       print this help, then exit
7873    -V, --version    print version number and configuration settings, then exit
7874 <  -q, --quiet      do not print progress messages
7874 >      --config     print configuration, then exit
7875 >  -q, --quiet, --silent
7876 >                   do not print progress messages
7877    -d, --debug      don't remove temporary files
7878        --recheck    update $as_me by reconfiguring in the same conditions
7879 <  --file=FILE[:TEMPLATE]
7880 <                   instantiate the configuration file FILE
7881 <  --header=FILE[:TEMPLATE]
7882 <                   instantiate the configuration header FILE
7879 >      --file=FILE[:TEMPLATE]
7880 >                   instantiate the configuration file FILE
7881 >      --header=FILE[:TEMPLATE]
7882 >                   instantiate the configuration header FILE
7883  
7884   Configuration files:
7885   $config_files
# Line 13385 | Line 7887 | $config_headers
7887   Configuration headers:
7888   $config_headers
7889  
7890 < Report bugs to <bug-autoconf@gnu.org>."
7890 > Report bugs to <gezelter@nd.edu>."
7891  
7892   _ACEOF
7893 < cat >>$CONFIG_STATUS <<_ACEOF
7893 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7894 > ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
7895   ac_cs_version="\\
7896 < OOPSE config.status 4.0
7897 < configured by $0, generated by GNU Autoconf 2.61,
7898 <  with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
7896 > OpenMD config.status 1.0
7897 > configured by $0, generated by GNU Autoconf 2.68,
7898 >  with options \\"\$ac_cs_config\\"
7899  
7900 < Copyright (C) 2006 Free Software Foundation, Inc.
7900 > Copyright (C) 2010 Free Software Foundation, Inc.
7901   This config.status script is free software; the Free Software Foundation
7902   gives unlimited permission to copy, distribute and modify it."
7903  
7904   ac_pwd='$ac_pwd'
7905   srcdir='$srcdir'
7906   INSTALL='$INSTALL'
7907 + test -n "\$AWK" || AWK=awk
7908   _ACEOF
7909  
7910 < cat >>$CONFIG_STATUS <<\_ACEOF
7911 < # If no file are specified by the user, then we need to provide default
13408 < # value.  By we need to know if files were specified by the user.
7910 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7911 > # The default lists apply if the user does not specify any file.
7912   ac_need_defaults=:
7913   while test $# != 0
7914   do
7915    case $1 in
7916 <  --*=*)
7916 >  --*=?*)
7917      ac_option=`expr "X$1" : 'X\([^=]*\)='`
7918      ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
7919      ac_shift=:
7920      ;;
7921 +  --*=)
7922 +    ac_option=`expr "X$1" : 'X\([^=]*\)='`
7923 +    ac_optarg=
7924 +    ac_shift=:
7925 +    ;;
7926    *)
7927      ac_option=$1
7928      ac_optarg=$2
# Line 13427 | Line 7935 | do
7935    -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
7936      ac_cs_recheck=: ;;
7937    --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
7938 <    echo "$ac_cs_version"; exit ;;
7938 >    $as_echo "$ac_cs_version"; exit ;;
7939 >  --config | --confi | --conf | --con | --co | --c )
7940 >    $as_echo "$ac_cs_config"; exit ;;
7941    --debug | --debu | --deb | --de | --d | -d )
7942      debug=: ;;
7943    --file | --fil | --fi | --f )
7944      $ac_shift
7945 <    CONFIG_FILES="$CONFIG_FILES $ac_optarg"
7945 >    case $ac_optarg in
7946 >    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7947 >    '') as_fn_error $? "missing file argument" ;;
7948 >    esac
7949 >    as_fn_append CONFIG_FILES " '$ac_optarg'"
7950      ac_need_defaults=false;;
7951    --header | --heade | --head | --hea )
7952      $ac_shift
7953 <    CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
7953 >    case $ac_optarg in
7954 >    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
7955 >    esac
7956 >    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
7957      ac_need_defaults=false;;
7958    --he | --h)
7959      # Conflict between --help and --header
7960 <    { echo "$as_me: error: ambiguous option: $1
7961 < Try \`$0 --help' for more information." >&2
13445 <   { (exit 1); exit 1; }; };;
7960 >    as_fn_error $? "ambiguous option: \`$1'
7961 > Try \`$0 --help' for more information.";;
7962    --help | --hel | -h )
7963 <    echo "$ac_cs_usage"; exit ;;
7963 >    $as_echo "$ac_cs_usage"; exit ;;
7964    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
7965    | -silent | --silent | --silen | --sile | --sil | --si | --s)
7966      ac_cs_silent=: ;;
7967  
7968    # This is an error.
7969 <  -*) { echo "$as_me: error: unrecognized option: $1
7970 < Try \`$0 --help' for more information." >&2
13455 <   { (exit 1); exit 1; }; } ;;
7969 >  -*) as_fn_error $? "unrecognized option: \`$1'
7970 > Try \`$0 --help' for more information." ;;
7971  
7972 <  *) ac_config_targets="$ac_config_targets $1"
7972 >  *) as_fn_append ac_config_targets " $1"
7973       ac_need_defaults=false ;;
7974  
7975    esac
# Line 13469 | Line 7984 | _ACEOF
7984   fi
7985  
7986   _ACEOF
7987 < cat >>$CONFIG_STATUS <<_ACEOF
7987 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
7988   if \$ac_cs_recheck; then
7989 <  echo "running CONFIG_SHELL=$SHELL $SHELL $0 "$ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
7990 <  CONFIG_SHELL=$SHELL
7989 >  set X '$SHELL' '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
7990 >  shift
7991 >  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
7992 >  CONFIG_SHELL='$SHELL'
7993    export CONFIG_SHELL
7994 <  exec $SHELL "$0"$ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
7994 >  exec "\$@"
7995   fi
7996  
7997   _ACEOF
7998 < cat >>$CONFIG_STATUS <<\_ACEOF
7998 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
7999   exec 5>>config.log
8000   {
8001    echo
8002    sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
8003   ## Running $as_me. ##
8004   _ASBOX
8005 <  echo "$ac_log"
8005 >  $as_echo "$ac_log"
8006   } >&5
8007  
8008   _ACEOF
8009 < cat >>$CONFIG_STATUS <<_ACEOF
8009 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8010   _ACEOF
8011  
8012 < cat >>$CONFIG_STATUS <<\_ACEOF
8012 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8013  
8014   # Handling of arguments.
8015   for ac_config_target in $ac_config_targets
# Line 13506 | Line 8023 | do
8023      "src/applications/atom2md/Makefile") CONFIG_FILES="$CONFIG_FILES src/applications/atom2md/Makefile" ;;
8024      "scripts/filepp") CONFIG_FILES="$CONFIG_FILES scripts/filepp" ;;
8025  
8026 <  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13510 < echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13511 <   { (exit 1); exit 1; }; };;
8026 >  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
8027    esac
8028   done
8029  
# Line 13530 | Line 8045 | $debug ||
8045   # after its creation but before its name has been assigned to `$tmp'.
8046   $debug ||
8047   {
8048 <  tmp=
8048 >  tmp= ac_tmp=
8049    trap 'exit_status=$?
8050 <  { test -z "$tmp" || test ! -d "$tmp" || rm -fr "$tmp"; } && exit $exit_status
8050 >  : "${ac_tmp:=$tmp}"
8051 >  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
8052   ' 0
8053 <  trap '{ (exit 1); exit 1; }' 1 2 13 15
8053 >  trap 'as_fn_exit 1' 1 2 13 15
8054   }
8055   # Create a (secure) tmp directory for tmp files.
8056  
8057   {
8058    tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
8059 <  test -n "$tmp" && test -d "$tmp"
8059 >  test -d "$tmp"
8060   }  ||
8061   {
8062    tmp=./conf$$-$RANDOM
8063    (umask 077 && mkdir "$tmp")
8064 < } ||
8065 < {
13550 <   echo "$me: cannot create a temporary directory in ." >&2
13551 <   { (exit 1); exit 1; }
13552 < }
8064 > } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
8065 > ac_tmp=$tmp
8066  
8067 < #
8068 < # Set up the sed scripts for CONFIG_FILES section.
8069 < #
13557 <
13558 < # No need to generate the scripts if there are no CONFIG_FILES.
13559 < # This happens for instance when ./config.status config.h
8067 > # Set up the scripts for CONFIG_FILES section.
8068 > # No need to generate them if there are no CONFIG_FILES.
8069 > # This happens for instance with `./config.status config.h'.
8070   if test -n "$CONFIG_FILES"; then
8071  
13562 – _ACEOF
8072  
8073 + ac_cr=`echo X | tr X '\015'`
8074 + # On cygwin, bash can eat \r inside `` if the user requested igncr.
8075 + # But we know of no other shell where ac_cr would be empty at this
8076 + # point, so we can use a bashism as a fallback.
8077 + if test "x$ac_cr" = x; then
8078 +  eval ac_cr=\$\'\\r\'
8079 + fi
8080 + ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
8081 + if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
8082 +  ac_cs_awk_cr='\\r'
8083 + else
8084 +  ac_cs_awk_cr=$ac_cr
8085 + fi
8086  
8087 + echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
8088 + _ACEOF
8089  
8090 +
8091 + {
8092 +  echo "cat >conf$$subs.awk <<_ACEOF" &&
8093 +  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
8094 +  echo "_ACEOF"
8095 + } >conf$$subs.sh ||
8096 +  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8097 + ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
8098   ac_delim='%!_!# '
8099   for ac_last_try in false false false false false :; do
8100 <  cat >conf$$subs.sed <<_ACEOF
8101 < SHELL!$SHELL$ac_delim
13570 < PATH_SEPARATOR!$PATH_SEPARATOR$ac_delim
13571 < PACKAGE_NAME!$PACKAGE_NAME$ac_delim
13572 < PACKAGE_TARNAME!$PACKAGE_TARNAME$ac_delim
13573 < PACKAGE_VERSION!$PACKAGE_VERSION$ac_delim
13574 < PACKAGE_STRING!$PACKAGE_STRING$ac_delim
13575 < PACKAGE_BUGREPORT!$PACKAGE_BUGREPORT$ac_delim
13576 < exec_prefix!$exec_prefix$ac_delim
13577 < prefix!$prefix$ac_delim
13578 < program_transform_name!$program_transform_name$ac_delim
13579 < bindir!$bindir$ac_delim
13580 < sbindir!$sbindir$ac_delim
13581 < libexecdir!$libexecdir$ac_delim
13582 < datarootdir!$datarootdir$ac_delim
13583 < datadir!$datadir$ac_delim
13584 < sysconfdir!$sysconfdir$ac_delim
13585 < sharedstatedir!$sharedstatedir$ac_delim
13586 < localstatedir!$localstatedir$ac_delim
13587 < includedir!$includedir$ac_delim
13588 < oldincludedir!$oldincludedir$ac_delim
13589 < docdir!$docdir$ac_delim
13590 < infodir!$infodir$ac_delim
13591 < htmldir!$htmldir$ac_delim
13592 < dvidir!$dvidir$ac_delim
13593 < pdfdir!$pdfdir$ac_delim
13594 < psdir!$psdir$ac_delim
13595 < libdir!$libdir$ac_delim
13596 < localedir!$localedir$ac_delim
13597 < mandir!$mandir$ac_delim
13598 < DEFS!$DEFS$ac_delim
13599 < ECHO_C!$ECHO_C$ac_delim
13600 < ECHO_N!$ECHO_N$ac_delim
13601 < ECHO_T!$ECHO_T$ac_delim
13602 < LIBS!$LIBS$ac_delim
13603 < build_alias!$build_alias$ac_delim
13604 < host_alias!$host_alias$ac_delim
13605 < target_alias!$target_alias$ac_delim
13606 < build!$build$ac_delim
13607 < build_cpu!$build_cpu$ac_delim
13608 < build_vendor!$build_vendor$ac_delim
13609 < build_os!$build_os$ac_delim
13610 < host!$host$ac_delim
13611 < host_cpu!$host_cpu$ac_delim
13612 < host_vendor!$host_vendor$ac_delim
13613 < host_os!$host_os$ac_delim
13614 < PROGNAME!$PROGNAME$ac_delim
13615 < debug!$debug$ac_delim
13616 < USE_SINGLE_PRECISION!$USE_SINGLE_PRECISION$ac_delim
13617 < ac_cc_set!$ac_cc_set$ac_delim
13618 < ac_cc_path!$ac_cc_path$ac_delim
13619 < ac_cxx_set!$ac_cxx_set$ac_delim
13620 < ac_cxx_path!$ac_cxx_path$ac_delim
13621 < ac_fc_set!$ac_fc_set$ac_delim
13622 < ac_fc_path!$ac_fc_path$ac_delim
13623 < acx_mpi_mpicc!$acx_mpi_mpicc$ac_delim
13624 < acx_mpi_mpicc_path!$acx_mpi_mpicc_path$ac_delim
13625 < acx_mpi_mpif90!$acx_mpi_mpif90$ac_delim
13626 < acx_mpi_mpif90_path!$acx_mpi_mpif90_path$ac_delim
13627 < acx_mpi_mpicxx!$acx_mpi_mpicxx$ac_delim
13628 < acx_mpi_mpicxx_path!$acx_mpi_mpicxx_path$ac_delim
13629 < MPI_CPPFLAGS!$MPI_CPPFLAGS$ac_delim
13630 < MPI_LIBS!$MPI_LIBS$ac_delim
13631 < MPI90_LIBS!$MPI90_LIBS$ac_delim
13632 < USE_MPI!$USE_MPI$ac_delim
13633 < CXX!$CXX$ac_delim
13634 < CXXFLAGS!$CXXFLAGS$ac_delim
13635 < LDFLAGS!$LDFLAGS$ac_delim
13636 < CPPFLAGS!$CPPFLAGS$ac_delim
13637 < ac_ct_CXX!$ac_ct_CXX$ac_delim
13638 < EXEEXT!$EXEEXT$ac_delim
13639 < OBJEXT!$OBJEXT$ac_delim
13640 < CC!$CC$ac_delim
13641 < CFLAGS!$CFLAGS$ac_delim
13642 < ac_ct_CC!$ac_ct_CC$ac_delim
13643 < FC!$FC$ac_delim
13644 < FCFLAGS!$FCFLAGS$ac_delim
13645 < ac_ct_FC!$ac_ct_FC$ac_delim
13646 < CPP!$CPP$ac_delim
13647 < GREP!$GREP$ac_delim
13648 < EGREP!$EGREP$ac_delim
13649 < LN_S!$LN_S$ac_delim
13650 < SET_MAKE!$SET_MAKE$ac_delim
13651 < RANLIB!$RANLIB$ac_delim
13652 < PERLINTERP!$PERLINTERP$ac_delim
13653 < PERL_SHEBANG!$PERL_SHEBANG$ac_delim
13654 < INSTALL_PROGRAM!$INSTALL_PROGRAM$ac_delim
13655 < INSTALL_SCRIPT!$INSTALL_SCRIPT$ac_delim
13656 < INSTALL_DATA!$INSTALL_DATA$ac_delim
13657 < AR!$AR$ac_delim
13658 < PS!$PS$ac_delim
13659 < FCFLAGS_F90!$FCFLAGS_F90$ac_delim
13660 < FCFLAGS_SRCEXT!$FCFLAGS_SRCEXT$ac_delim
13661 < PREPDEFFLAG!$PREPDEFFLAG$ac_delim
13662 < FCLIBS!$FCLIBS$ac_delim
13663 < FC_FUNC!$FC_FUNC$ac_delim
13664 < FC_FUNC_!$FC_FUNC_$ac_delim
13665 < MOD!$MOD$ac_delim
13666 < _ACEOF
8100 >  . ./conf$$subs.sh ||
8101 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8102  
8103 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then
8103 >  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
8104 >  if test $ac_delim_n = $ac_delim_num; then
8105      break
8106    elif $ac_last_try; then
8107 <    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
13672 < echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
13673 <   { (exit 1); exit 1; }; }
8107 >    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
8108    else
8109      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
8110    fi
8111   done
8112 + rm -f conf$$subs.sh
8113  
8114 < ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
8115 < if test -n "$ac_eof"; then
8116 <  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
8117 <  ac_eof=`expr $ac_eof + 1`
8118 < fi
8114 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8115 > cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
8116 > _ACEOF
8117 > sed -n '
8118 > h
8119 > s/^/S["/; s/!.*/"]=/
8120 > p
8121 > g
8122 > s/^[^!]*!//
8123 > :repl
8124 > t repl
8125 > s/'"$ac_delim"'$//
8126 > t delim
8127 > :nl
8128 > h
8129 > s/\(.\{148\}\)..*/\1/
8130 > t more1
8131 > s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/
8132 > p
8133 > n
8134 > b repl
8135 > :more1
8136 > s/["\\]/\\&/g; s/^/"/; s/$/"\\/
8137 > p
8138 > g
8139 > s/.\{148\}//
8140 > t nl
8141 > :delim
8142 > h
8143 > s/\(.\{148\}\)..*/\1/
8144 > t more2
8145 > s/["\\]/\\&/g; s/^/"/; s/$/"/
8146 > p
8147 > b
8148 > :more2
8149 > s/["\\]/\\&/g; s/^/"/; s/$/"\\/
8150 > p
8151 > g
8152 > s/.\{148\}//
8153 > t delim
8154 > ' <conf$$subs.awk | sed '
8155 > /^[^""]/{
8156 >  N
8157 >  s/\n//
8158 > }
8159 > ' >>$CONFIG_STATUS || ac_write_fail=1
8160 > rm -f conf$$subs.awk
8161 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8162 > _ACAWK
8163 > cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
8164 >  for (key in S) S_is_set[key] = 1
8165 >  FS = ""
8166  
8167 < cat >>$CONFIG_STATUS <<_ACEOF
8168 < cat >"\$tmp/subs-1.sed" <<\CEOF$ac_eof
8169 < /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
8167 > }
8168 > {
8169 >  line = $ 0
8170 >  nfields = split(line, field, "@")
8171 >  substed = 0
8172 >  len = length(field[1])
8173 >  for (i = 2; i < nfields; i++) {
8174 >    key = field[i]
8175 >    keylen = length(key)
8176 >    if (S_is_set[key]) {
8177 >      value = S[key]
8178 >      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
8179 >      len += length(value) + length(field[++i])
8180 >      substed = 1
8181 >    } else
8182 >      len += 1 + keylen
8183 >  }
8184 >
8185 >  print line
8186 > }
8187 >
8188 > _ACAWK
8189   _ACEOF
8190 < sed '
8191 < s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
8192 < s/^/s,@/; s/!/@,|#_!!_#|/
8193 < :n
8194 < t n
8195 < s/'"$ac_delim"'$/,g/; t
8196 < s/$/\\/; p
13696 < N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
13697 < ' >>$CONFIG_STATUS <conf$$subs.sed
13698 < rm -f conf$$subs.sed
13699 < cat >>$CONFIG_STATUS <<_ACEOF
13700 < CEOF$ac_eof
8190 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8191 > if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
8192 >  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
8193 > else
8194 >  cat
8195 > fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
8196 >  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
8197   _ACEOF
8198  
8199 + # VPATH may cause trouble with some makes, so we remove sole $(srcdir),
8200 + # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
8201 + # trailing colons and then remove the whole line if VPATH becomes empty
8202 + # (actually we leave an empty line to preserve line numbers).
8203 + if test "x$srcdir" = x.; then
8204 +  ac_vpsub='/^[  ]*VPATH[        ]*=[    ]*/{
8205 + h
8206 + s///
8207 + s/^/:/
8208 + s/[      ]*$/:/
8209 + s/:\$(srcdir):/:/g
8210 + s/:\${srcdir}:/:/g
8211 + s/:@srcdir@:/:/g
8212 + s/^:*//
8213 + s/:*$//
8214 + x
8215 + s/\(=[   ]*\).*/\1/
8216 + G
8217 + s/\n//
8218 + s/^[^=]*=[       ]*$//
8219 + }'
8220 + fi
8221  
8222 < ac_delim='%!_!# '
8223 < for ac_last_try in false false false false false :; do
8224 <  cat >conf$$subs.sed <<_ACEOF
8225 < F90_WORK_FILES_ARG!$F90_WORK_FILES_ARG$ac_delim
8226 < MODDIRFLAG!$MODDIRFLAG$ac_delim
8227 < F90MODINCSPEC!$F90MODINCSPEC$ac_delim
8228 < F90_MODULE_NAMES!$F90_MODULE_NAMES$ac_delim
8229 < ZLIB_INC_DIR!$ZLIB_INC_DIR$ac_delim
8230 < ZLIB_LIB_DIR!$ZLIB_LIB_DIR$ac_delim
13713 < ZLIB!$ZLIB$ac_delim
13714 < FFTW_INC_DIR!$FFTW_INC_DIR$ac_delim
13715 < FFTW_LIB_DIR!$FFTW_LIB_DIR$ac_delim
13716 < FFTW_LIBS!$FFTW_LIBS$ac_delim
13717 < QHULL_INC_DIR!$QHULL_INC_DIR$ac_delim
13718 < QHULL_LIB_DIR!$QHULL_LIB_DIR$ac_delim
13719 < QHULL!$QHULL$ac_delim
13720 < USE_QHULL!$USE_QHULL$ac_delim
13721 < CXXCPP!$CXXCPP$ac_delim
13722 < OPENBABEL_INC_DIR!$OPENBABEL_INC_DIR$ac_delim
13723 < OPENBABEL_LIB_DIR!$OPENBABEL_LIB_DIR$ac_delim
13724 < OPENBABEL_LIB!$OPENBABEL_LIB$ac_delim
13725 < USE_OPENBABEL!$USE_OPENBABEL$ac_delim
13726 < LIBOBJS!$LIBOBJS$ac_delim
13727 < POW_LIB!$POW_LIB$ac_delim
13728 < CGAL_MAKEFILE!$CGAL_MAKEFILE$ac_delim
13729 < CGAL_CXXFLAGS!$CGAL_CXXFLAGS$ac_delim
13730 < CGAL_CPPFLAGS!$CGAL_CPPFLAGS$ac_delim
13731 < CGAL_LDFLAGS!$CGAL_LDFLAGS$ac_delim
13732 < CGAL_LIBS!$CGAL_LIBS$ac_delim
13733 < USE_CGAL!$USE_CGAL$ac_delim
13734 < DOXYGEN!$DOXYGEN$ac_delim
13735 < DOT!$DOT$ac_delim
13736 < DOC!$DOC$ac_delim
13737 < enable_dot!$enable_dot$ac_delim
13738 < enable_html_docs!$enable_html_docs$ac_delim
13739 < enable_latex_docs!$enable_latex_docs$ac_delim
13740 < BATEXT!$BATEXT$ac_delim
13741 < MKINSTALLDIRS!$MKINSTALLDIRS$ac_delim
13742 < OOPSE!$OOPSE$ac_delim
13743 < OOPSE_HOME!$OOPSE_HOME$ac_delim
13744 < SUBDIRS!$SUBDIRS$ac_delim
13745 < LTLIBOBJS!$LTLIBOBJS$ac_delim
8222 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8223 > fi # test -n "$CONFIG_FILES"
8224 >
8225 > # Set up the scripts for CONFIG_HEADERS section.
8226 > # No need to generate them if there are no CONFIG_HEADERS.
8227 > # This happens for instance with `./config.status Makefile'.
8228 > if test -n "$CONFIG_HEADERS"; then
8229 > cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
8230 > BEGIN {
8231   _ACEOF
8232  
8233 <  if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 39; then
8233 > # Transform confdefs.h into an awk script `defines.awk', embedded as
8234 > # here-document in config.status, that substitutes the proper values into
8235 > # config.h.in to produce config.h.
8236 >
8237 > # Create a delimiter string that does not exist in confdefs.h, to ease
8238 > # handling of long lines.
8239 > ac_delim='%!_!# '
8240 > for ac_last_try in false false :; do
8241 >  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
8242 >  if test -z "$ac_tt"; then
8243      break
8244    elif $ac_last_try; then
8245 <    { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5
13752 < echo "$as_me: error: could not make $CONFIG_STATUS" >&2;}
13753 <   { (exit 1); exit 1; }; }
8245 >    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
8246    else
8247      ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
8248    fi
8249   done
8250  
8251 < ac_eof=`sed -n '/^CEOF[0-9]*$/s/CEOF/0/p' conf$$subs.sed`
8252 < if test -n "$ac_eof"; then
8253 <  ac_eof=`echo "$ac_eof" | sort -nru | sed 1q`
13762 <  ac_eof=`expr $ac_eof + 1`
13763 < fi
8251 > # For the awk script, D is an array of macro values keyed by name,
8252 > # likewise P contains macro parameters if any.  Preserve backslash
8253 > # newline sequences.
8254  
8255 < cat >>$CONFIG_STATUS <<_ACEOF
8256 < cat >"\$tmp/subs-2.sed" <<\CEOF$ac_eof
8257 < /@[a-zA-Z_][a-zA-Z_0-9]*@/!b end
8255 > ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
8256 > sed -n '
8257 > s/.\{148\}/&'"$ac_delim"'/g
8258 > t rset
8259 > :rset
8260 > s/^[     ]*#[    ]*define[       ][      ]*/ /
8261 > t def
8262 > d
8263 > :def
8264 > s/\\$//
8265 > t bsnl
8266 > s/["\\]/\\&/g
8267 > s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
8268 > D["\1"]=" \3"/p
8269 > s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2"/p
8270 > d
8271 > :bsnl
8272 > s/["\\]/\\&/g
8273 > s/^ \('"$ac_word_re"'\)\(([^()]*)\)[     ]*\(.*\)/P["\1"]="\2"\
8274 > D["\1"]=" \3\\\\\\n"\\/p
8275 > t cont
8276 > s/^ \('"$ac_word_re"'\)[         ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p
8277 > t cont
8278 > d
8279 > :cont
8280 > n
8281 > s/.\{148\}/&'"$ac_delim"'/g
8282 > t clear
8283 > :clear
8284 > s/\\$//
8285 > t bsnlc
8286 > s/["\\]/\\&/g; s/^/"/; s/$/"/p
8287 > d
8288 > :bsnlc
8289 > s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
8290 > b cont
8291 > ' <confdefs.h | sed '
8292 > s/'"$ac_delim"'/"\\\
8293 > "/g' >>$CONFIG_STATUS || ac_write_fail=1
8294 >
8295 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8296 >  for (key in D) D_is_set[key] = 1
8297 >  FS = ""
8298 > }
8299 > /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ {
8300 >  line = \$ 0
8301 >  split(line, arg, " ")
8302 >  if (arg[1] == "#") {
8303 >    defundef = arg[2]
8304 >    mac1 = arg[3]
8305 >  } else {
8306 >    defundef = substr(arg[1], 2)
8307 >    mac1 = arg[2]
8308 >  }
8309 >  split(mac1, mac2, "(") #)
8310 >  macro = mac2[1]
8311 >  prefix = substr(line, 1, index(line, defundef) - 1)
8312 >  if (D_is_set[macro]) {
8313 >    # Preserve the white space surrounding the "#".
8314 >    print prefix "define", macro P[macro] D[macro]
8315 >    next
8316 >  } else {
8317 >    # Replace #undef with comments.  This is necessary, for example,
8318 >    # in the case of _POSIX_SOURCE, which is predefined and required
8319 >    # on some systems where configure will not decide to define it.
8320 >    if (defundef == "undef") {
8321 >      print "/*", prefix defundef, macro, "*/"
8322 >      next
8323 >    }
8324 >  }
8325 > }
8326 > { print }
8327 > _ACAWK
8328   _ACEOF
8329 < sed '
8330 < s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g
8331 < s/^/s,@/; s/!/@,|#_!!_#|/
13772 < :n
13773 < t n
13774 < s/'"$ac_delim"'$/,g/; t
13775 < s/$/\\/; p
13776 < N; s/^.*\n//; s/[,\\&]/\\&/g; s/@/@|#_!!_#|/g; b n
13777 < ' >>$CONFIG_STATUS <conf$$subs.sed
13778 < rm -f conf$$subs.sed
13779 < cat >>$CONFIG_STATUS <<_ACEOF
13780 < :end
13781 < s/|#_!!_#|//g
13782 < CEOF$ac_eof
13783 < _ACEOF
8329 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8330 >  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
8331 > fi # test -n "$CONFIG_HEADERS"
8332  
8333  
8334 < # VPATH may cause trouble with some makes, so we remove $(srcdir),
8335 < # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
8336 < # trailing colons and then remove the whole line if VPATH becomes empty
13789 < # (actually we leave an empty line to preserve line numbers).
13790 < if test "x$srcdir" = x.; then
13791 <  ac_vpsub='/^[  ]*VPATH[        ]*=/{
13792 < s/:*\$(srcdir):*/:/
13793 < s/:*\${srcdir}:*/:/
13794 < s/:*@srcdir@:*/:/
13795 < s/^\([^=]*=[     ]*\):*/\1/
13796 < s/:*$//
13797 < s/^[^=]*=[       ]*$//
13798 < }'
13799 < fi
13800 <
13801 < cat >>$CONFIG_STATUS <<\_ACEOF
13802 < fi # test -n "$CONFIG_FILES"
13803 <
13804 <
13805 < for ac_tag in  :F $CONFIG_FILES  :H $CONFIG_HEADERS
8334 > eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    "
8335 > shift
8336 > for ac_tag
8337   do
8338    case $ac_tag in
8339    :[FHLC]) ac_mode=$ac_tag; continue;;
8340    esac
8341    case $ac_mode$ac_tag in
8342    :[FHL]*:*);;
8343 <  :L* | :C*:*) { { echo "$as_me:$LINENO: error: Invalid tag $ac_tag." >&5
13813 < echo "$as_me: error: Invalid tag $ac_tag." >&2;}
13814 <   { (exit 1); exit 1; }; };;
8343 >  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
8344    :[FH]-) ac_tag=-:-;;
8345    :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
8346    esac
# Line 13830 | Line 8359 | echo "$as_me: error: Invalid tag $ac_tag." >&2;}
8359      for ac_f
8360      do
8361        case $ac_f in
8362 <      -) ac_f="$tmp/stdin";;
8362 >      -) ac_f="$ac_tmp/stdin";;
8363        *) # Look for the file first in the build tree, then in the source tree
8364           # (if the path is not absolute).  The absolute path cannot be DOS-style,
8365           # because $ac_f cannot contain `:'.
# Line 13839 | Line 8368 | echo "$as_me: error: Invalid tag $ac_tag." >&2;}
8368             [\\/$]*) false;;
8369             *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
8370             esac ||
8371 <           { { echo "$as_me:$LINENO: error: cannot find input file: $ac_f" >&5
13843 < echo "$as_me: error: cannot find input file: $ac_f" >&2;}
13844 <   { (exit 1); exit 1; }; };;
8371 >           as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
8372        esac
8373 <      ac_file_inputs="$ac_file_inputs $ac_f"
8373 >      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
8374 >      as_fn_append ac_file_inputs " '$ac_f'"
8375      done
8376  
8377      # Let's still pretend it is `configure' which instantiates (i.e., don't
8378      # use $as_me), people would be surprised to read:
8379      #    /* config.h.  Generated by config.status.  */
8380 <    configure_input="Generated from "`IFS=:
8381 <          echo $* | sed 's|^[^:]*/||;s|:[^:]*/|, |g'`" by configure."
8380 >    configure_input='Generated from '`
8381 >          $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
8382 >        `' by configure.'
8383      if test x"$ac_file" != x-; then
8384        configure_input="$ac_file.  $configure_input"
8385 <      { echo "$as_me:$LINENO: creating $ac_file" >&5
8386 < echo "$as_me: creating $ac_file" >&6;}
8385 >      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
8386 > $as_echo "$as_me: creating $ac_file" >&6;}
8387      fi
8388 +    # Neutralize special characters interpreted by sed in replacement strings.
8389 +    case $configure_input in #(
8390 +    *\&* | *\|* | *\\* )
8391 +       ac_sed_conf_input=`$as_echo "$configure_input" |
8392 +       sed 's/[\\\\&|]/\\\\&/g'`;; #(
8393 +    *) ac_sed_conf_input=$configure_input;;
8394 +    esac
8395  
8396      case $ac_tag in
8397 <    *:-:* | *:-) cat >"$tmp/stdin";;
8397 >    *:-:* | *:-) cat >"$ac_tmp/stdin" \
8398 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
8399      esac
8400      ;;
8401    esac
# Line 13868 | Line 8405 | $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \|
8405           X"$ac_file" : 'X\(//\)[^/]' \| \
8406           X"$ac_file" : 'X\(//\)$' \| \
8407           X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
8408 < echo X"$ac_file" |
8408 > $as_echo X"$ac_file" |
8409      sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
8410              s//\1/
8411              q
# Line 13886 | Line 8423 | echo X"$ac_file" |
8423              q
8424            }
8425            s/.*/./; q'`
8426 <  { as_dir="$ac_dir"
13890 <  case $as_dir in #(
13891 <  -*) as_dir=./$as_dir;;
13892 <  esac
13893 <  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
13894 <    as_dirs=
13895 <    while :; do
13896 <      case $as_dir in #(
13897 <      *\'*) as_qdir=`echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #(
13898 <      *) as_qdir=$as_dir;;
13899 <      esac
13900 <      as_dirs="'$as_qdir' $as_dirs"
13901 <      as_dir=`$as_dirname -- "$as_dir" ||
13902 < $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13903 <         X"$as_dir" : 'X\(//\)[^/]' \| \
13904 <         X"$as_dir" : 'X\(//\)$' \| \
13905 <         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
13906 < echo X"$as_dir" |
13907 <    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
13908 <            s//\1/
13909 <            q
13910 <          }
13911 <          /^X\(\/\/\)[^/].*/{
13912 <            s//\1/
13913 <            q
13914 <          }
13915 <          /^X\(\/\/\)$/{
13916 <            s//\1/
13917 <            q
13918 <          }
13919 <          /^X\(\/\).*/{
13920 <            s//\1/
13921 <            q
13922 <          }
13923 <          s/.*/./; q'`
13924 <      test -d "$as_dir" && break
13925 <    done
13926 <    test -z "$as_dirs" || eval "mkdir $as_dirs"
13927 <  } || test -d "$as_dir" || { { echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
13928 < echo "$as_me: error: cannot create directory $as_dir" >&2;}
13929 <   { (exit 1); exit 1; }; }; }
8426 >  as_dir="$ac_dir"; as_fn_mkdir_p
8427    ac_builddir=.
8428  
8429   case "$ac_dir" in
8430   .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
8431   *)
8432 <  ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
8432 >  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
8433    # A ".." for each directory in $ac_dir_suffix.
8434 <  ac_top_builddir_sub=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,/..,g;s,/,,'`
8434 >  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
8435    case $ac_top_builddir_sub in
8436    "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
8437    *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
# Line 13974 | Line 8471 | _ACEOF
8471    esac
8472   _ACEOF
8473  
8474 < cat >>$CONFIG_STATUS <<\_ACEOF
8474 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8475   # If the template does not know about datarootdir, expand it.
8476   # FIXME: This hack should be removed a few years after 2.60.
8477   ac_datarootdir_hack=; ac_datarootdir_seen=
8478 <
8479 < case `sed -n '/datarootdir/ {
8478 > ac_sed_dataroot='
8479 > /datarootdir/ {
8480    p
8481    q
8482   }
# Line 13987 | Line 8484 | case `sed -n '/datarootdir/ {
8484   /@docdir@/p
8485   /@infodir@/p
8486   /@localedir@/p
8487 < /@mandir@/p
8488 < ' $ac_file_inputs` in
8487 > /@mandir@/p'
8488 > case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
8489   *datarootdir*) ac_datarootdir_seen=yes;;
8490   *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
8491 <  { echo "$as_me:$LINENO: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8492 < echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
8491 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
8492 > $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
8493   _ACEOF
8494 < cat >>$CONFIG_STATUS <<_ACEOF
8494 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8495    ac_datarootdir_hack='
8496    s&@datadir@&$datadir&g
8497    s&@docdir@&$docdir&g
8498    s&@infodir@&$infodir&g
8499    s&@localedir@&$localedir&g
8500    s&@mandir@&$mandir&g
8501 <    s&\\\${datarootdir}&$datarootdir&g' ;;
8501 >  s&\\\${datarootdir}&$datarootdir&g' ;;
8502   esac
8503   _ACEOF
8504  
8505   # Neutralize VPATH when `$srcdir' = `.'.
8506   # Shell code in configure.ac might set extrasub.
8507   # FIXME: do we really want to maintain this feature?
8508 < cat >>$CONFIG_STATUS <<_ACEOF
8509 <  sed "$ac_vpsub
8508 > cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
8509 > ac_sed_extra="$ac_vpsub
8510   $extrasub
8511   _ACEOF
8512 < cat >>$CONFIG_STATUS <<\_ACEOF
8512 > cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
8513   :t
8514   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
8515 < s&@configure_input@&$configure_input&;t t
8515 > s|@configure_input@|$ac_sed_conf_input|;t t
8516   s&@top_builddir@&$ac_top_builddir_sub&;t t
8517 + s&@top_build_prefix@&$ac_top_build_prefix&;t t
8518   s&@srcdir@&$ac_srcdir&;t t
8519   s&@abs_srcdir@&$ac_abs_srcdir&;t t
8520   s&@top_srcdir@&$ac_top_srcdir&;t t
# Line 14026 | Line 8524 | $ac_datarootdir_hack
8524   s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
8525   s&@INSTALL@&$ac_INSTALL&;t t
8526   $ac_datarootdir_hack
8527 < " $ac_file_inputs | sed -f "$tmp/subs-1.sed" | sed -f "$tmp/subs-2.sed" >$tmp/out
8527 > "
8528 > eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
8529 >  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8530  
8531   test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
8532 <  { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
8533 <  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
8534 <  { echo "$as_me:$LINENO: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8535 < which seems to be undefined.  Please make sure it is defined." >&5
8536 < echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8537 < which seems to be undefined.  Please make sure it is defined." >&2;}
8532 >  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
8533 >  { ac_out=`sed -n '/^[  ]*datarootdir[  ]*:*=/p' \
8534 >      "$ac_tmp/out"`; test -z "$ac_out"; } &&
8535 >  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8536 > which seems to be undefined.  Please make sure it is defined" >&5
8537 > $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
8538 > which seems to be undefined.  Please make sure it is defined" >&2;}
8539  
8540 <  rm -f "$tmp/stdin"
8540 >  rm -f "$ac_tmp/stdin"
8541    case $ac_file in
8542 <  -) cat "$tmp/out"; rm -f "$tmp/out";;
8543 <  *) rm -f "$ac_file"; mv "$tmp/out" $ac_file;;
8544 <  esac
8542 >  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
8543 >  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
8544 >  esac \
8545 >  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8546   ;;
8547    :H)
8548    #
8549    # CONFIG_HEADER
8550    #
14049 – _ACEOF
14050 –
14051 – # Transform confdefs.h into a sed script `conftest.defines', that
14052 – # substitutes the proper values into config.h.in to produce config.h.
14053 – rm -f conftest.defines conftest.tail
14054 – # First, append a space to every undef/define line, to ease matching.
14055 – echo 's/$/ /' >conftest.defines
14056 – # Then, protect against being on the right side of a sed subst, or in
14057 – # an unquoted here document, in config.status.  If some macros were
14058 – # called several times there might be several #defines for the same
14059 – # symbol, which is useless.  But do not sort them, since the last
14060 – # AC_DEFINE must be honored.
14061 – ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]*
14062 – # These sed commands are passed to sed as "A NAME B PARAMS C VALUE D", where
14063 – # NAME is the cpp macro being defined, VALUE is the value it is being given.
14064 – # PARAMS is the parameter list in the macro definition--in most cases, it's
14065 – # just an empty string.
14066 – ac_dA='s,^\\([   #]*\\)[^        ]*\\([  ]*'
14067 – ac_dB='\\)[      (].*,\\1define\\2'
14068 – ac_dC=' '
14069 – ac_dD=' ,'
14070 –
14071 – uniq confdefs.h |
14072 –  sed -n '
14073 –        t rset
14074 –        :rset
14075 –        s/^[     ]*#[    ]*define[       ][      ]*//
14076 –        t ok
14077 –        d
14078 –        :ok
14079 –        s/[\\&,]/\\&/g
14080 –        s/^\('"$ac_word_re"'\)\(([^()]*)\)[      ]*\(.*\)/ '"$ac_dA"'\1'"$ac_dB"'\2'"${ac_dC}"'\3'"$ac_dD"'/p
14081 –        s/^\('"$ac_word_re"'\)[  ]*\(.*\)/'"$ac_dA"'\1'"$ac_dB$ac_dC"'\2'"$ac_dD"'/p
14082 –  ' >>conftest.defines
14083 –
14084 – # Remove the space that was appended to ease matching.
14085 – # Then replace #undef with comments.  This is necessary, for
14086 – # example, in the case of _POSIX_SOURCE, which is predefined and required
14087 – # on some systems where configure will not decide to define it.
14088 – # (The regexp can be short, since the line contains either #define or #undef.)
14089 – echo 's/ $//
14090 – s,^[     #]*u.*,/* & */,' >>conftest.defines
14091 –
14092 – # Break up conftest.defines:
14093 – ac_max_sed_lines=50
14094 –
14095 – # First sed command is:  sed -f defines.sed $ac_file_inputs >"$tmp/out1"
14096 – # Second one is:         sed -f defines.sed "$tmp/out1" >"$tmp/out2"
14097 – # Third one will be:     sed -f defines.sed "$tmp/out2" >"$tmp/out1"
14098 – # et cetera.
14099 – ac_in='$ac_file_inputs'
14100 – ac_out='"$tmp/out1"'
14101 – ac_nxt='"$tmp/out2"'
14102 –
14103 – while :
14104 – do
14105 –  # Write a here document:
14106 –    cat >>$CONFIG_STATUS <<_ACEOF
14107 –    # First, check the format of the line:
14108 –    cat >"\$tmp/defines.sed" <<\\CEOF
14109 – /^[      ]*#[    ]*undef[        ][      ]*$ac_word_re[  ]*\$/b def
14110 – /^[      ]*#[    ]*define[       ][      ]*$ac_word_re[(         ]/b def
14111 – b
14112 – :def
14113 – _ACEOF
14114 –  sed ${ac_max_sed_lines}q conftest.defines >>$CONFIG_STATUS
14115 –  echo 'CEOF
14116 –    sed -f "$tmp/defines.sed"' "$ac_in >$ac_out" >>$CONFIG_STATUS
14117 –  ac_in=$ac_out; ac_out=$ac_nxt; ac_nxt=$ac_in
14118 –  sed 1,${ac_max_sed_lines}d conftest.defines >conftest.tail
14119 –  grep . conftest.tail >/dev/null || break
14120 –  rm -f conftest.defines
14121 –  mv conftest.tail conftest.defines
14122 – done
14123 – rm -f conftest.defines conftest.tail
14124 –
14125 – echo "ac_result=$ac_in" >>$CONFIG_STATUS
14126 – cat >>$CONFIG_STATUS <<\_ACEOF
8551    if test x"$ac_file" != x-; then
8552 <    echo "/* $configure_input  */" >"$tmp/config.h"
8553 <    cat "$ac_result" >>"$tmp/config.h"
8554 <    if diff $ac_file "$tmp/config.h" >/dev/null 2>&1; then
8555 <      { echo "$as_me:$LINENO: $ac_file is unchanged" >&5
8556 < echo "$as_me: $ac_file is unchanged" >&6;}
8552 >    {
8553 >      $as_echo "/* $configure_input  */" \
8554 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
8555 >    } >"$ac_tmp/config.h" \
8556 >      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8557 >    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
8558 >      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
8559 > $as_echo "$as_me: $ac_file is unchanged" >&6;}
8560      else
8561 <      rm -f $ac_file
8562 <      mv "$tmp/config.h" $ac_file
8561 >      rm -f "$ac_file"
8562 >      mv "$ac_tmp/config.h" "$ac_file" \
8563 >        || as_fn_error $? "could not create $ac_file" "$LINENO" 5
8564      fi
8565    else
8566 <    echo "/* $configure_input  */"
8567 <    cat "$ac_result"
8566 >    $as_echo "/* $configure_input  */" \
8567 >      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
8568 >      || as_fn_error $? "could not create -" "$LINENO" 5
8569    fi
14141 –  rm -f "$tmp/out12"
8570   ;;
8571  
8572  
# Line 14157 | Line 8585 | done # for ac_tag
8585   done # for ac_tag
8586  
8587  
8588 < { (exit 0); exit 0; }
8588 > as_fn_exit 0
8589   _ACEOF
14162 – chmod +x $CONFIG_STATUS
8590   ac_clean_files=$ac_clean_files_save
8591  
8592 + test $ac_write_fail = 0 ||
8593 +  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
8594  
8595 +
8596   # configure is writing to config.log, and then calls config.status.
8597   # config.status does its own redirection, appending to config.log.
8598   # Unfortunately, on DOS this fails, as config.log is still kept open
# Line 14181 | Line 8611 | if test "$no_create" != yes; then
8611    exec 5>>config.log
8612    # Use ||, not &&, to avoid exiting from the if with $? = 1, which
8613    # would make configure fail if this is the last instruction.
8614 <  $ac_cs_success || { (exit 1); exit 1; }
8614 >  $ac_cs_success || as_fn_exit 1
8615   fi
8616 + if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
8617 +  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
8618 + $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
8619 + fi
8620  

Diff Legend

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