Ignore:
Timestamp:
Jun 18, 2008 3:08:45 PM (14 years ago)
Author:
gah
Message:

fixes to optimizer build

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/optimizer/src/configure

    r1049 r1052  
    595595PACKAGE_NAME='RapptureOptimizer'
    596596PACKAGE_TARNAME='rapptureoptimizer'
    597 PACKAGE_VERSION='1.0'
     597PACKAGE_VERSION='1.1'
    598598PACKAGE_STRING='RapptureOptimizer 1.0'
    599599PACKAGE_BUGREPORT=''
     
    635635#endif"
    636636
     637enable_option_checking=no
    637638ac_subst_vars='SHELL
    638639PATH_SEPARATOR
     
    715716EGREP
    716717MATH_LIBS
     718F77
     719FFLAGS
     720ac_ct_F77
    717721PKG_SOURCES
    718722PKG_OBJECTS
     
    745749EXACT_VERSION
    746750NODOT_VERSION
     751subdirs
    747752LTLIBOBJS'
    748753ac_subst_files=''
     
    771776CXXFLAGS
    772777CCC
    773 CPP'
    774 
     778CPP
     779F77
     780FFLAGS'
     781ac_subdirs_all='pgapack '
    775782
    776783# Initialize some variables set by options.
     
    14221429  CXXFLAGS    C++ compiler flags
    14231430  CPP         C preprocessor
     1431  F77         Fortran 77 compiler command
     1432  FFLAGS      Fortran 77 compiler flags
    14241433
    14251434Use these variables to override the choices made by `configure' or to help
     
    72197228    fi
    72207229
     7230ac_ext=f
     7231ac_compile='$F77 -c $FFLAGS conftest.$ac_ext >&5'
     7232ac_link='$F77 -o conftest$ac_exeext $FFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     7233ac_compiler_gnu=$ac_cv_f77_compiler_gnu
     7234if test -n "$ac_tool_prefix"; then
     7235  for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
     7236  do
     7237    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     7238set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     7239{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7240$as_echo_n "checking for $ac_word... " >&6; }
     7241if test "${ac_cv_prog_F77+set}" = set; then
     7242  $as_echo_n "(cached) " >&6
     7243else
     7244  if test -n "$F77"; then
     7245  ac_cv_prog_F77="$F77" # Let the user override the test.
     7246else
     7247as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7248for as_dir in $PATH
     7249do
     7250  IFS=$as_save_IFS
     7251  test -z "$as_dir" && as_dir=.
     7252  for ac_exec_ext in '' $ac_executable_extensions; do
     7253  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7254    ac_cv_prog_F77="$ac_tool_prefix$ac_prog"
     7255    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7256    break 2
     7257  fi
     7258done
     7259done
     7260IFS=$as_save_IFS
     7261
     7262fi
     7263fi
     7264F77=$ac_cv_prog_F77
     7265if test -n "$F77"; then
     7266  { $as_echo "$as_me:$LINENO: result: $F77" >&5
     7267$as_echo "$F77" >&6; }
     7268else
     7269  { $as_echo "$as_me:$LINENO: result: no" >&5
     7270$as_echo "no" >&6; }
     7271fi
     7272
     7273
     7274    test -n "$F77" && break
     7275  done
     7276fi
     7277if test -z "$F77"; then
     7278  ac_ct_F77=$F77
     7279  for ac_prog in g77 xlf f77 frt pgf77 cf77 fort77 fl32 af77 xlf90 f90 pgf90 pghpf epcf90 gfortran g95 xlf95 f95 fort ifort ifc efc pgf95 lf95 ftn
     7280do
     7281  # Extract the first word of "$ac_prog", so it can be a program name with args.
     7282set dummy $ac_prog; ac_word=$2
     7283{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7284$as_echo_n "checking for $ac_word... " >&6; }
     7285if test "${ac_cv_prog_ac_ct_F77+set}" = set; then
     7286  $as_echo_n "(cached) " >&6
     7287else
     7288  if test -n "$ac_ct_F77"; then
     7289  ac_cv_prog_ac_ct_F77="$ac_ct_F77" # Let the user override the test.
     7290else
     7291as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7292for as_dir in $PATH
     7293do
     7294  IFS=$as_save_IFS
     7295  test -z "$as_dir" && as_dir=.
     7296  for ac_exec_ext in '' $ac_executable_extensions; do
     7297  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7298    ac_cv_prog_ac_ct_F77="$ac_prog"
     7299    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7300    break 2
     7301  fi
     7302done
     7303done
     7304IFS=$as_save_IFS
     7305
     7306fi
     7307fi
     7308ac_ct_F77=$ac_cv_prog_ac_ct_F77
     7309if test -n "$ac_ct_F77"; then
     7310  { $as_echo "$as_me:$LINENO: result: $ac_ct_F77" >&5
     7311$as_echo "$ac_ct_F77" >&6; }
     7312else
     7313  { $as_echo "$as_me:$LINENO: result: no" >&5
     7314$as_echo "no" >&6; }
     7315fi
     7316
     7317
     7318  test -n "$ac_ct_F77" && break
     7319done
     7320
     7321  if test "x$ac_ct_F77" = x; then
     7322    F77=""
     7323  else
     7324    case $cross_compiling:$ac_tool_warned in
     7325yes:)
     7326{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     7327whose name does not start with the host triplet.  If you think this
     7328configuration is useful to you, please write to autoconf@gnu.org." >&5
     7329$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     7330whose name does not start with the host triplet.  If you think this
     7331configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     7332ac_tool_warned=yes ;;
     7333esac
     7334    F77=$ac_ct_F77
     7335  fi
     7336fi
     7337
     7338
     7339# Provide some information about the compiler.
     7340$as_echo "$as_me:$LINENO: checking for Fortran 77 compiler version" >&5
     7341set X $ac_compile
     7342ac_compiler=$2
     7343{ (ac_try="$ac_compiler --version >&5"
     7344case "(($ac_try" in
     7345  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7346  *) ac_try_echo=$ac_try;;
     7347esac
     7348eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7349$as_echo "$ac_try_echo") >&5
     7350  (eval "$ac_compiler --version >&5") 2>&5
     7351  ac_status=$?
     7352  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7353  (exit $ac_status); }
     7354{ (ac_try="$ac_compiler -v >&5"
     7355case "(($ac_try" in
     7356  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7357  *) ac_try_echo=$ac_try;;
     7358esac
     7359eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7360$as_echo "$ac_try_echo") >&5
     7361  (eval "$ac_compiler -v >&5") 2>&5
     7362  ac_status=$?
     7363  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7364  (exit $ac_status); }
     7365{ (ac_try="$ac_compiler -V >&5"
     7366case "(($ac_try" in
     7367  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7368  *) ac_try_echo=$ac_try;;
     7369esac
     7370eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7371$as_echo "$ac_try_echo") >&5
     7372  (eval "$ac_compiler -V >&5") 2>&5
     7373  ac_status=$?
     7374  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7375  (exit $ac_status); }
     7376rm -f a.out
     7377
     7378# If we don't use `.F' as extension, the preprocessor is not run on the
     7379# input file.  (Note that this only needs to work for GNU compilers.)
     7380ac_save_ext=$ac_ext
     7381ac_ext=F
     7382{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU Fortran 77 compiler" >&5
     7383$as_echo_n "checking whether we are using the GNU Fortran 77 compiler... " >&6; }
     7384if test "${ac_cv_f77_compiler_gnu+set}" = set; then
     7385  $as_echo_n "(cached) " >&6
     7386else
     7387  cat >conftest.$ac_ext <<_ACEOF
     7388      program main
     7389#ifndef __GNUC__
     7390       choke me
     7391#endif
     7392
     7393      end
     7394_ACEOF
     7395rm -f conftest.$ac_objext
     7396if { (ac_try="$ac_compile"
     7397case "(($ac_try" in
     7398  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7399  *) ac_try_echo=$ac_try;;
     7400esac
     7401eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7402$as_echo "$ac_try_echo") >&5
     7403  (eval "$ac_compile") 2>conftest.er1
     7404  ac_status=$?
     7405  grep -v '^ *+' conftest.er1 >conftest.err
     7406  rm -f conftest.er1
     7407  cat conftest.err >&5
     7408  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7409  (exit $ac_status); } && {
     7410         test -z "$ac_f77_werror_flag" ||
     7411         test ! -s conftest.err
     7412       } && test -s conftest.$ac_objext; then
     7413  ac_compiler_gnu=yes
     7414else
     7415  $as_echo "$as_me: failed program was:" >&5
     7416sed 's/^/| /' conftest.$ac_ext >&5
     7417
     7418        ac_compiler_gnu=no
     7419fi
     7420
     7421rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     7422ac_cv_f77_compiler_gnu=$ac_compiler_gnu
     7423
     7424fi
     7425{ $as_echo "$as_me:$LINENO: result: $ac_cv_f77_compiler_gnu" >&5
     7426$as_echo "$ac_cv_f77_compiler_gnu" >&6; }
     7427ac_ext=$ac_save_ext
     7428ac_test_FFLAGS=${FFLAGS+set}
     7429ac_save_FFLAGS=$FFLAGS
     7430FFLAGS=
     7431{ $as_echo "$as_me:$LINENO: checking whether $F77 accepts -g" >&5
     7432$as_echo_n "checking whether $F77 accepts -g... " >&6; }
     7433if test "${ac_cv_prog_f77_g+set}" = set; then
     7434  $as_echo_n "(cached) " >&6
     7435else
     7436  FFLAGS=-g
     7437cat >conftest.$ac_ext <<_ACEOF
     7438      program main
     7439
     7440      end
     7441_ACEOF
     7442rm -f conftest.$ac_objext
     7443if { (ac_try="$ac_compile"
     7444case "(($ac_try" in
     7445  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7446  *) ac_try_echo=$ac_try;;
     7447esac
     7448eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7449$as_echo "$ac_try_echo") >&5
     7450  (eval "$ac_compile") 2>conftest.er1
     7451  ac_status=$?
     7452  grep -v '^ *+' conftest.er1 >conftest.err
     7453  rm -f conftest.er1
     7454  cat conftest.err >&5
     7455  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7456  (exit $ac_status); } && {
     7457         test -z "$ac_f77_werror_flag" ||
     7458         test ! -s conftest.err
     7459       } && test -s conftest.$ac_objext; then
     7460  ac_cv_prog_f77_g=yes
     7461else
     7462  $as_echo "$as_me: failed program was:" >&5
     7463sed 's/^/| /' conftest.$ac_ext >&5
     7464
     7465        ac_cv_prog_f77_g=no
     7466fi
     7467
     7468rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     7469
     7470fi
     7471{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_f77_g" >&5
     7472$as_echo "$ac_cv_prog_f77_g" >&6; }
     7473if test "$ac_test_FFLAGS" = set; then
     7474  FFLAGS=$ac_save_FFLAGS
     7475elif test $ac_cv_prog_f77_g = yes; then
     7476  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
     7477    FFLAGS="-g -O2"
     7478  else
     7479    FFLAGS="-g"
     7480  fi
     7481else
     7482  if test "x$ac_cv_f77_compiler_gnu" = xyes; then
     7483    FFLAGS="-O2"
     7484  else
     7485    FFLAGS=
     7486  fi
     7487fi
     7488
     7489if test $ac_compiler_gnu = yes; then
     7490  G77=yes
     7491else
     7492  G77=
     7493fi
     7494ac_ext=c
     7495ac_cpp='$CPP $CPPFLAGS'
     7496ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     7497ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     7498ac_compiler_gnu=$ac_cv_c_compiler_gnu
     7499
     7500ac_ext=c
     7501ac_cpp='$CPP $CPPFLAGS'
     7502ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     7503ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     7504ac_compiler_gnu=$ac_cv_c_compiler_gnu
     7505if test -n "$ac_tool_prefix"; then
     7506  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
     7507set dummy ${ac_tool_prefix}gcc; ac_word=$2
     7508{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7509$as_echo_n "checking for $ac_word... " >&6; }
     7510if test "${ac_cv_prog_CC+set}" = set; then
     7511  $as_echo_n "(cached) " >&6
     7512else
     7513  if test -n "$CC"; then
     7514  ac_cv_prog_CC="$CC" # Let the user override the test.
     7515else
     7516as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7517for as_dir in $PATH
     7518do
     7519  IFS=$as_save_IFS
     7520  test -z "$as_dir" && as_dir=.
     7521  for ac_exec_ext in '' $ac_executable_extensions; do
     7522  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7523    ac_cv_prog_CC="${ac_tool_prefix}gcc"
     7524    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7525    break 2
     7526  fi
     7527done
     7528done
     7529IFS=$as_save_IFS
     7530
     7531fi
     7532fi
     7533CC=$ac_cv_prog_CC
     7534if test -n "$CC"; then
     7535  { $as_echo "$as_me:$LINENO: result: $CC" >&5
     7536$as_echo "$CC" >&6; }
     7537else
     7538  { $as_echo "$as_me:$LINENO: result: no" >&5
     7539$as_echo "no" >&6; }
     7540fi
     7541
     7542
     7543fi
     7544if test -z "$ac_cv_prog_CC"; then
     7545  ac_ct_CC=$CC
     7546  # Extract the first word of "gcc", so it can be a program name with args.
     7547set dummy gcc; ac_word=$2
     7548{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7549$as_echo_n "checking for $ac_word... " >&6; }
     7550if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
     7551  $as_echo_n "(cached) " >&6
     7552else
     7553  if test -n "$ac_ct_CC"; then
     7554  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
     7555else
     7556as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7557for as_dir in $PATH
     7558do
     7559  IFS=$as_save_IFS
     7560  test -z "$as_dir" && as_dir=.
     7561  for ac_exec_ext in '' $ac_executable_extensions; do
     7562  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7563    ac_cv_prog_ac_ct_CC="gcc"
     7564    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7565    break 2
     7566  fi
     7567done
     7568done
     7569IFS=$as_save_IFS
     7570
     7571fi
     7572fi
     7573ac_ct_CC=$ac_cv_prog_ac_ct_CC
     7574if test -n "$ac_ct_CC"; then
     7575  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
     7576$as_echo "$ac_ct_CC" >&6; }
     7577else
     7578  { $as_echo "$as_me:$LINENO: result: no" >&5
     7579$as_echo "no" >&6; }
     7580fi
     7581
     7582  if test "x$ac_ct_CC" = x; then
     7583    CC=""
     7584  else
     7585    case $cross_compiling:$ac_tool_warned in
     7586yes:)
     7587{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     7588whose name does not start with the host triplet.  If you think this
     7589configuration is useful to you, please write to autoconf@gnu.org." >&5
     7590$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     7591whose name does not start with the host triplet.  If you think this
     7592configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     7593ac_tool_warned=yes ;;
     7594esac
     7595    CC=$ac_ct_CC
     7596  fi
     7597else
     7598  CC="$ac_cv_prog_CC"
     7599fi
     7600
     7601if test -z "$CC"; then
     7602          if test -n "$ac_tool_prefix"; then
     7603    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
     7604set dummy ${ac_tool_prefix}cc; ac_word=$2
     7605{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7606$as_echo_n "checking for $ac_word... " >&6; }
     7607if test "${ac_cv_prog_CC+set}" = set; then
     7608  $as_echo_n "(cached) " >&6
     7609else
     7610  if test -n "$CC"; then
     7611  ac_cv_prog_CC="$CC" # Let the user override the test.
     7612else
     7613as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7614for as_dir in $PATH
     7615do
     7616  IFS=$as_save_IFS
     7617  test -z "$as_dir" && as_dir=.
     7618  for ac_exec_ext in '' $ac_executable_extensions; do
     7619  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7620    ac_cv_prog_CC="${ac_tool_prefix}cc"
     7621    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7622    break 2
     7623  fi
     7624done
     7625done
     7626IFS=$as_save_IFS
     7627
     7628fi
     7629fi
     7630CC=$ac_cv_prog_CC
     7631if test -n "$CC"; then
     7632  { $as_echo "$as_me:$LINENO: result: $CC" >&5
     7633$as_echo "$CC" >&6; }
     7634else
     7635  { $as_echo "$as_me:$LINENO: result: no" >&5
     7636$as_echo "no" >&6; }
     7637fi
     7638
     7639
     7640  fi
     7641fi
     7642if test -z "$CC"; then
     7643  # Extract the first word of "cc", so it can be a program name with args.
     7644set dummy cc; ac_word=$2
     7645{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7646$as_echo_n "checking for $ac_word... " >&6; }
     7647if test "${ac_cv_prog_CC+set}" = set; then
     7648  $as_echo_n "(cached) " >&6
     7649else
     7650  if test -n "$CC"; then
     7651  ac_cv_prog_CC="$CC" # Let the user override the test.
     7652else
     7653  ac_prog_rejected=no
     7654as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7655for as_dir in $PATH
     7656do
     7657  IFS=$as_save_IFS
     7658  test -z "$as_dir" && as_dir=.
     7659  for ac_exec_ext in '' $ac_executable_extensions; do
     7660  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7661    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
     7662       ac_prog_rejected=yes
     7663       continue
     7664     fi
     7665    ac_cv_prog_CC="cc"
     7666    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7667    break 2
     7668  fi
     7669done
     7670done
     7671IFS=$as_save_IFS
     7672
     7673if test $ac_prog_rejected = yes; then
     7674  # We found a bogon in the path, so make sure we never use it.
     7675  set dummy $ac_cv_prog_CC
     7676  shift
     7677  if test $# != 0; then
     7678    # We chose a different compiler from the bogus one.
     7679    # However, it has the same basename, so the bogon will be chosen
     7680    # first if we set CC to just the basename; use the full file name.
     7681    shift
     7682    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
     7683  fi
     7684fi
     7685fi
     7686fi
     7687CC=$ac_cv_prog_CC
     7688if test -n "$CC"; then
     7689  { $as_echo "$as_me:$LINENO: result: $CC" >&5
     7690$as_echo "$CC" >&6; }
     7691else
     7692  { $as_echo "$as_me:$LINENO: result: no" >&5
     7693$as_echo "no" >&6; }
     7694fi
     7695
     7696
     7697fi
     7698if test -z "$CC"; then
     7699  if test -n "$ac_tool_prefix"; then
     7700  for ac_prog in cl.exe
     7701  do
     7702    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     7703set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     7704{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7705$as_echo_n "checking for $ac_word... " >&6; }
     7706if test "${ac_cv_prog_CC+set}" = set; then
     7707  $as_echo_n "(cached) " >&6
     7708else
     7709  if test -n "$CC"; then
     7710  ac_cv_prog_CC="$CC" # Let the user override the test.
     7711else
     7712as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7713for as_dir in $PATH
     7714do
     7715  IFS=$as_save_IFS
     7716  test -z "$as_dir" && as_dir=.
     7717  for ac_exec_ext in '' $ac_executable_extensions; do
     7718  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7719    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
     7720    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7721    break 2
     7722  fi
     7723done
     7724done
     7725IFS=$as_save_IFS
     7726
     7727fi
     7728fi
     7729CC=$ac_cv_prog_CC
     7730if test -n "$CC"; then
     7731  { $as_echo "$as_me:$LINENO: result: $CC" >&5
     7732$as_echo "$CC" >&6; }
     7733else
     7734  { $as_echo "$as_me:$LINENO: result: no" >&5
     7735$as_echo "no" >&6; }
     7736fi
     7737
     7738
     7739    test -n "$CC" && break
     7740  done
     7741fi
     7742if test -z "$CC"; then
     7743  ac_ct_CC=$CC
     7744  for ac_prog in cl.exe
     7745do
     7746  # Extract the first word of "$ac_prog", so it can be a program name with args.
     7747set dummy $ac_prog; ac_word=$2
     7748{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     7749$as_echo_n "checking for $ac_word... " >&6; }
     7750if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
     7751  $as_echo_n "(cached) " >&6
     7752else
     7753  if test -n "$ac_ct_CC"; then
     7754  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
     7755else
     7756as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     7757for as_dir in $PATH
     7758do
     7759  IFS=$as_save_IFS
     7760  test -z "$as_dir" && as_dir=.
     7761  for ac_exec_ext in '' $ac_executable_extensions; do
     7762  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     7763    ac_cv_prog_ac_ct_CC="$ac_prog"
     7764    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     7765    break 2
     7766  fi
     7767done
     7768done
     7769IFS=$as_save_IFS
     7770
     7771fi
     7772fi
     7773ac_ct_CC=$ac_cv_prog_ac_ct_CC
     7774if test -n "$ac_ct_CC"; then
     7775  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
     7776$as_echo "$ac_ct_CC" >&6; }
     7777else
     7778  { $as_echo "$as_me:$LINENO: result: no" >&5
     7779$as_echo "no" >&6; }
     7780fi
     7781
     7782
     7783  test -n "$ac_ct_CC" && break
     7784done
     7785
     7786  if test "x$ac_ct_CC" = x; then
     7787    CC=""
     7788  else
     7789    case $cross_compiling:$ac_tool_warned in
     7790yes:)
     7791{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     7792whose name does not start with the host triplet.  If you think this
     7793configuration is useful to you, please write to autoconf@gnu.org." >&5
     7794$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     7795whose name does not start with the host triplet.  If you think this
     7796configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     7797ac_tool_warned=yes ;;
     7798esac
     7799    CC=$ac_ct_CC
     7800  fi
     7801fi
     7802
     7803fi
     7804
     7805
     7806test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
     7807See \`config.log' for more details." >&5
     7808$as_echo "$as_me: error: no acceptable C compiler found in \$PATH
     7809See \`config.log' for more details." >&2;}
     7810   { (exit 1); exit 1; }; }
     7811
     7812# Provide some information about the compiler.
     7813$as_echo "$as_me:$LINENO: checking for C compiler version" >&5
     7814set X $ac_compile
     7815ac_compiler=$2
     7816{ (ac_try="$ac_compiler --version >&5"
     7817case "(($ac_try" in
     7818  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7819  *) ac_try_echo=$ac_try;;
     7820esac
     7821eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7822$as_echo "$ac_try_echo") >&5
     7823  (eval "$ac_compiler --version >&5") 2>&5
     7824  ac_status=$?
     7825  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7826  (exit $ac_status); }
     7827{ (ac_try="$ac_compiler -v >&5"
     7828case "(($ac_try" in
     7829  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7830  *) ac_try_echo=$ac_try;;
     7831esac
     7832eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7833$as_echo "$ac_try_echo") >&5
     7834  (eval "$ac_compiler -v >&5") 2>&5
     7835  ac_status=$?
     7836  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7837  (exit $ac_status); }
     7838{ (ac_try="$ac_compiler -V >&5"
     7839case "(($ac_try" in
     7840  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7841  *) ac_try_echo=$ac_try;;
     7842esac
     7843eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7844$as_echo "$ac_try_echo") >&5
     7845  (eval "$ac_compiler -V >&5") 2>&5
     7846  ac_status=$?
     7847  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7848  (exit $ac_status); }
     7849
     7850{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
     7851$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
     7852if test "${ac_cv_c_compiler_gnu+set}" = set; then
     7853  $as_echo_n "(cached) " >&6
     7854else
     7855  cat >conftest.$ac_ext <<_ACEOF
     7856/* confdefs.h.  */
     7857_ACEOF
     7858cat confdefs.h >>conftest.$ac_ext
     7859cat >>conftest.$ac_ext <<_ACEOF
     7860/* end confdefs.h.  */
     7861
     7862int
     7863main ()
     7864{
     7865#ifndef __GNUC__
     7866       choke me
     7867#endif
     7868
     7869  ;
     7870  return 0;
     7871}
     7872_ACEOF
     7873rm -f conftest.$ac_objext
     7874if { (ac_try="$ac_compile"
     7875case "(($ac_try" in
     7876  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7877  *) ac_try_echo=$ac_try;;
     7878esac
     7879eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7880$as_echo "$ac_try_echo") >&5
     7881  (eval "$ac_compile") 2>conftest.er1
     7882  ac_status=$?
     7883  grep -v '^ *+' conftest.er1 >conftest.err
     7884  rm -f conftest.er1
     7885  cat conftest.err >&5
     7886  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7887  (exit $ac_status); } && {
     7888         test -z "$ac_c_werror_flag" ||
     7889         test ! -s conftest.err
     7890       } && test -s conftest.$ac_objext; then
     7891  ac_compiler_gnu=yes
     7892else
     7893  $as_echo "$as_me: failed program was:" >&5
     7894sed 's/^/| /' conftest.$ac_ext >&5
     7895
     7896        ac_compiler_gnu=no
     7897fi
     7898
     7899rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     7900ac_cv_c_compiler_gnu=$ac_compiler_gnu
     7901
     7902fi
     7903{ $as_echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
     7904$as_echo "$ac_cv_c_compiler_gnu" >&6; }
     7905if test $ac_compiler_gnu = yes; then
     7906  GCC=yes
     7907else
     7908  GCC=
     7909fi
     7910ac_test_CFLAGS=${CFLAGS+set}
     7911ac_save_CFLAGS=$CFLAGS
     7912{ $as_echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
     7913$as_echo_n "checking whether $CC accepts -g... " >&6; }
     7914if test "${ac_cv_prog_cc_g+set}" = set; then
     7915  $as_echo_n "(cached) " >&6
     7916else
     7917  ac_save_c_werror_flag=$ac_c_werror_flag
     7918   ac_c_werror_flag=yes
     7919   ac_cv_prog_cc_g=no
     7920   CFLAGS="-g"
     7921   cat >conftest.$ac_ext <<_ACEOF
     7922/* confdefs.h.  */
     7923_ACEOF
     7924cat confdefs.h >>conftest.$ac_ext
     7925cat >>conftest.$ac_ext <<_ACEOF
     7926/* end confdefs.h.  */
     7927
     7928int
     7929main ()
     7930{
     7931
     7932  ;
     7933  return 0;
     7934}
     7935_ACEOF
     7936rm -f conftest.$ac_objext
     7937if { (ac_try="$ac_compile"
     7938case "(($ac_try" in
     7939  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7940  *) ac_try_echo=$ac_try;;
     7941esac
     7942eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7943$as_echo "$ac_try_echo") >&5
     7944  (eval "$ac_compile") 2>conftest.er1
     7945  ac_status=$?
     7946  grep -v '^ *+' conftest.er1 >conftest.err
     7947  rm -f conftest.er1
     7948  cat conftest.err >&5
     7949  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7950  (exit $ac_status); } && {
     7951         test -z "$ac_c_werror_flag" ||
     7952         test ! -s conftest.err
     7953       } && test -s conftest.$ac_objext; then
     7954  ac_cv_prog_cc_g=yes
     7955else
     7956  $as_echo "$as_me: failed program was:" >&5
     7957sed 's/^/| /' conftest.$ac_ext >&5
     7958
     7959        CFLAGS=""
     7960      cat >conftest.$ac_ext <<_ACEOF
     7961/* confdefs.h.  */
     7962_ACEOF
     7963cat confdefs.h >>conftest.$ac_ext
     7964cat >>conftest.$ac_ext <<_ACEOF
     7965/* end confdefs.h.  */
     7966
     7967int
     7968main ()
     7969{
     7970
     7971  ;
     7972  return 0;
     7973}
     7974_ACEOF
     7975rm -f conftest.$ac_objext
     7976if { (ac_try="$ac_compile"
     7977case "(($ac_try" in
     7978  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     7979  *) ac_try_echo=$ac_try;;
     7980esac
     7981eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     7982$as_echo "$ac_try_echo") >&5
     7983  (eval "$ac_compile") 2>conftest.er1
     7984  ac_status=$?
     7985  grep -v '^ *+' conftest.er1 >conftest.err
     7986  rm -f conftest.er1
     7987  cat conftest.err >&5
     7988  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     7989  (exit $ac_status); } && {
     7990         test -z "$ac_c_werror_flag" ||
     7991         test ! -s conftest.err
     7992       } && test -s conftest.$ac_objext; then
     7993  :
     7994else
     7995  $as_echo "$as_me: failed program was:" >&5
     7996sed 's/^/| /' conftest.$ac_ext >&5
     7997
     7998        ac_c_werror_flag=$ac_save_c_werror_flag
     7999         CFLAGS="-g"
     8000         cat >conftest.$ac_ext <<_ACEOF
     8001/* confdefs.h.  */
     8002_ACEOF
     8003cat confdefs.h >>conftest.$ac_ext
     8004cat >>conftest.$ac_ext <<_ACEOF
     8005/* end confdefs.h.  */
     8006
     8007int
     8008main ()
     8009{
     8010
     8011  ;
     8012  return 0;
     8013}
     8014_ACEOF
     8015rm -f conftest.$ac_objext
     8016if { (ac_try="$ac_compile"
     8017case "(($ac_try" in
     8018  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8019  *) ac_try_echo=$ac_try;;
     8020esac
     8021eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8022$as_echo "$ac_try_echo") >&5
     8023  (eval "$ac_compile") 2>conftest.er1
     8024  ac_status=$?
     8025  grep -v '^ *+' conftest.er1 >conftest.err
     8026  rm -f conftest.er1
     8027  cat conftest.err >&5
     8028  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8029  (exit $ac_status); } && {
     8030         test -z "$ac_c_werror_flag" ||
     8031         test ! -s conftest.err
     8032       } && test -s conftest.$ac_objext; then
     8033  ac_cv_prog_cc_g=yes
     8034else
     8035  $as_echo "$as_me: failed program was:" >&5
     8036sed 's/^/| /' conftest.$ac_ext >&5
     8037
     8038
     8039fi
     8040
     8041rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8042fi
     8043
     8044rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8045fi
     8046
     8047rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8048   ac_c_werror_flag=$ac_save_c_werror_flag
     8049fi
     8050{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
     8051$as_echo "$ac_cv_prog_cc_g" >&6; }
     8052if test "$ac_test_CFLAGS" = set; then
     8053  CFLAGS=$ac_save_CFLAGS
     8054elif test $ac_cv_prog_cc_g = yes; then
     8055  if test "$GCC" = yes; then
     8056    CFLAGS="-g -O2"
     8057  else
     8058    CFLAGS="-g"
     8059  fi
     8060else
     8061  if test "$GCC" = yes; then
     8062    CFLAGS="-O2"
     8063  else
     8064    CFLAGS=
     8065  fi
     8066fi
     8067{ $as_echo "$as_me:$LINENO: checking for $CC option to accept ISO C89" >&5
     8068$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
     8069if test "${ac_cv_prog_cc_c89+set}" = set; then
     8070  $as_echo_n "(cached) " >&6
     8071else
     8072  ac_cv_prog_cc_c89=no
     8073ac_save_CC=$CC
     8074cat >conftest.$ac_ext <<_ACEOF
     8075/* confdefs.h.  */
     8076_ACEOF
     8077cat confdefs.h >>conftest.$ac_ext
     8078cat >>conftest.$ac_ext <<_ACEOF
     8079/* end confdefs.h.  */
     8080#include <stdarg.h>
     8081#include <stdio.h>
     8082#include <sys/types.h>
     8083#include <sys/stat.h>
     8084/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
     8085struct buf { int x; };
     8086FILE * (*rcsopen) (struct buf *, struct stat *, int);
     8087static char *e (p, i)
     8088     char **p;
     8089     int i;
     8090{
     8091  return p[i];
     8092}
     8093static char *f (char * (*g) (char **, int), char **p, ...)
     8094{
     8095  char *s;
     8096  va_list v;
     8097  va_start (v,p);
     8098  s = g (p, va_arg (v,int));
     8099  va_end (v);
     8100  return s;
     8101}
     8102
     8103/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
     8104   function prototypes and stuff, but not '\xHH' hex character constants.
     8105   These don't provoke an error unfortunately, instead are silently treated
     8106   as 'x'.  The following induces an error, until -std is added to get
     8107   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
     8108   array size at least.  It's necessary to write '\x00'==0 to get something
     8109   that's true only with -std.  */
     8110int osf4_cc_array ['\x00' == 0 ? 1 : -1];
     8111
     8112/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
     8113   inside strings and character constants.  */
     8114#define FOO(x) 'x'
     8115int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
     8116
     8117int test (int i, double x);
     8118struct s1 {int (*f) (int a);};
     8119struct s2 {int (*f) (double a);};
     8120int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
     8121int argc;
     8122char **argv;
     8123int
     8124main ()
     8125{
     8126return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
     8127  ;
     8128  return 0;
     8129}
     8130_ACEOF
     8131for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
     8132        -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
     8133do
     8134  CC="$ac_save_CC $ac_arg"
     8135  rm -f conftest.$ac_objext
     8136if { (ac_try="$ac_compile"
     8137case "(($ac_try" in
     8138  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8139  *) ac_try_echo=$ac_try;;
     8140esac
     8141eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8142$as_echo "$ac_try_echo") >&5
     8143  (eval "$ac_compile") 2>conftest.er1
     8144  ac_status=$?
     8145  grep -v '^ *+' conftest.er1 >conftest.err
     8146  rm -f conftest.er1
     8147  cat conftest.err >&5
     8148  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8149  (exit $ac_status); } && {
     8150         test -z "$ac_c_werror_flag" ||
     8151         test ! -s conftest.err
     8152       } && test -s conftest.$ac_objext; then
     8153  ac_cv_prog_cc_c89=$ac_arg
     8154else
     8155  $as_echo "$as_me: failed program was:" >&5
     8156sed 's/^/| /' conftest.$ac_ext >&5
     8157
     8158
     8159fi
     8160
     8161rm -f core conftest.err conftest.$ac_objext
     8162  test "x$ac_cv_prog_cc_c89" != "xno" && break
     8163done
     8164rm -f conftest.$ac_ext
     8165CC=$ac_save_CC
     8166
     8167fi
     8168# AC_CACHE_VAL
     8169case "x$ac_cv_prog_cc_c89" in
     8170  x)
     8171    { $as_echo "$as_me:$LINENO: result: none needed" >&5
     8172$as_echo "none needed" >&6; } ;;
     8173  xno)
     8174    { $as_echo "$as_me:$LINENO: result: unsupported" >&5
     8175$as_echo "unsupported" >&6; } ;;
     8176  *)
     8177    CC="$CC $ac_cv_prog_cc_c89"
     8178    { $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cc_c89" >&5
     8179$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
     8180esac
     8181
     8182
     8183ac_ext=c
     8184ac_cpp='$CPP $CPPFLAGS'
     8185ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     8186ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     8187ac_compiler_gnu=$ac_cv_c_compiler_gnu
     8188
     8189ac_ext=c
     8190ac_cpp='$CPP $CPPFLAGS'
     8191ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     8192ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     8193ac_compiler_gnu=$ac_cv_c_compiler_gnu
     8194{ $as_echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
     8195$as_echo_n "checking how to run the C preprocessor... " >&6; }
     8196# On Suns, sometimes $CPP names a directory.
     8197if test -n "$CPP" && test -d "$CPP"; then
     8198  CPP=
     8199fi
     8200if test -z "$CPP"; then
     8201  if test "${ac_cv_prog_CPP+set}" = set; then
     8202  $as_echo_n "(cached) " >&6
     8203else
     8204      # Double quotes because CPP needs to be expanded
     8205    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
     8206    do
     8207      ac_preproc_ok=false
     8208for ac_c_preproc_warn_flag in '' yes
     8209do
     8210  # Use a header file that comes with gcc, so configuring glibc
     8211  # with a fresh cross-compiler works.
     8212  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     8213  # <limits.h> exists even on freestanding compilers.
     8214  # On the NeXT, cc -E runs the code through the compiler's parser,
     8215  # not just through cpp. "Syntax error" is here to catch this case.
     8216  cat >conftest.$ac_ext <<_ACEOF
     8217/* confdefs.h.  */
     8218_ACEOF
     8219cat confdefs.h >>conftest.$ac_ext
     8220cat >>conftest.$ac_ext <<_ACEOF
     8221/* end confdefs.h.  */
     8222#ifdef __STDC__
     8223# include <limits.h>
     8224#else
     8225# include <assert.h>
     8226#endif
     8227                     Syntax error
     8228_ACEOF
     8229if { (ac_try="$ac_cpp conftest.$ac_ext"
     8230case "(($ac_try" in
     8231  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8232  *) ac_try_echo=$ac_try;;
     8233esac
     8234eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8235$as_echo "$ac_try_echo") >&5
     8236  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     8237  ac_status=$?
     8238  grep -v '^ *+' conftest.er1 >conftest.err
     8239  rm -f conftest.er1
     8240  cat conftest.err >&5
     8241  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8242  (exit $ac_status); } >/dev/null && {
     8243         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
     8244         test ! -s conftest.err
     8245       }; then
     8246  :
     8247else
     8248  $as_echo "$as_me: failed program was:" >&5
     8249sed 's/^/| /' conftest.$ac_ext >&5
     8250
     8251  # Broken: fails on valid input.
     8252continue
     8253fi
     8254
     8255rm -f conftest.err conftest.$ac_ext
     8256
     8257  # OK, works on sane cases.  Now check whether nonexistent headers
     8258  # can be detected and how.
     8259  cat >conftest.$ac_ext <<_ACEOF
     8260/* confdefs.h.  */
     8261_ACEOF
     8262cat confdefs.h >>conftest.$ac_ext
     8263cat >>conftest.$ac_ext <<_ACEOF
     8264/* end confdefs.h.  */
     8265#include <ac_nonexistent.h>
     8266_ACEOF
     8267if { (ac_try="$ac_cpp conftest.$ac_ext"
     8268case "(($ac_try" in
     8269  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8270  *) ac_try_echo=$ac_try;;
     8271esac
     8272eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8273$as_echo "$ac_try_echo") >&5
     8274  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     8275  ac_status=$?
     8276  grep -v '^ *+' conftest.er1 >conftest.err
     8277  rm -f conftest.er1
     8278  cat conftest.err >&5
     8279  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8280  (exit $ac_status); } >/dev/null && {
     8281         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
     8282         test ! -s conftest.err
     8283       }; then
     8284  # Broken: success on invalid input.
     8285continue
     8286else
     8287  $as_echo "$as_me: failed program was:" >&5
     8288sed 's/^/| /' conftest.$ac_ext >&5
     8289
     8290  # Passes both tests.
     8291ac_preproc_ok=:
     8292break
     8293fi
     8294
     8295rm -f conftest.err conftest.$ac_ext
     8296
     8297done
     8298# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     8299rm -f conftest.err conftest.$ac_ext
     8300if $ac_preproc_ok; then
     8301  break
     8302fi
     8303
     8304    done
     8305    ac_cv_prog_CPP=$CPP
     8306
     8307fi
     8308  CPP=$ac_cv_prog_CPP
     8309else
     8310  ac_cv_prog_CPP=$CPP
     8311fi
     8312{ $as_echo "$as_me:$LINENO: result: $CPP" >&5
     8313$as_echo "$CPP" >&6; }
     8314ac_preproc_ok=false
     8315for ac_c_preproc_warn_flag in '' yes
     8316do
     8317  # Use a header file that comes with gcc, so configuring glibc
     8318  # with a fresh cross-compiler works.
     8319  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
     8320  # <limits.h> exists even on freestanding compilers.
     8321  # On the NeXT, cc -E runs the code through the compiler's parser,
     8322  # not just through cpp. "Syntax error" is here to catch this case.
     8323  cat >conftest.$ac_ext <<_ACEOF
     8324/* confdefs.h.  */
     8325_ACEOF
     8326cat confdefs.h >>conftest.$ac_ext
     8327cat >>conftest.$ac_ext <<_ACEOF
     8328/* end confdefs.h.  */
     8329#ifdef __STDC__
     8330# include <limits.h>
     8331#else
     8332# include <assert.h>
     8333#endif
     8334                     Syntax error
     8335_ACEOF
     8336if { (ac_try="$ac_cpp conftest.$ac_ext"
     8337case "(($ac_try" in
     8338  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8339  *) ac_try_echo=$ac_try;;
     8340esac
     8341eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8342$as_echo "$ac_try_echo") >&5
     8343  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     8344  ac_status=$?
     8345  grep -v '^ *+' conftest.er1 >conftest.err
     8346  rm -f conftest.er1
     8347  cat conftest.err >&5
     8348  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8349  (exit $ac_status); } >/dev/null && {
     8350         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
     8351         test ! -s conftest.err
     8352       }; then
     8353  :
     8354else
     8355  $as_echo "$as_me: failed program was:" >&5
     8356sed 's/^/| /' conftest.$ac_ext >&5
     8357
     8358  # Broken: fails on valid input.
     8359continue
     8360fi
     8361
     8362rm -f conftest.err conftest.$ac_ext
     8363
     8364  # OK, works on sane cases.  Now check whether nonexistent headers
     8365  # can be detected and how.
     8366  cat >conftest.$ac_ext <<_ACEOF
     8367/* confdefs.h.  */
     8368_ACEOF
     8369cat confdefs.h >>conftest.$ac_ext
     8370cat >>conftest.$ac_ext <<_ACEOF
     8371/* end confdefs.h.  */
     8372#include <ac_nonexistent.h>
     8373_ACEOF
     8374if { (ac_try="$ac_cpp conftest.$ac_ext"
     8375case "(($ac_try" in
     8376  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8377  *) ac_try_echo=$ac_try;;
     8378esac
     8379eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8380$as_echo "$ac_try_echo") >&5
     8381  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1
     8382  ac_status=$?
     8383  grep -v '^ *+' conftest.er1 >conftest.err
     8384  rm -f conftest.er1
     8385  cat conftest.err >&5
     8386  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8387  (exit $ac_status); } >/dev/null && {
     8388         test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
     8389         test ! -s conftest.err
     8390       }; then
     8391  # Broken: success on invalid input.
     8392continue
     8393else
     8394  $as_echo "$as_me: failed program was:" >&5
     8395sed 's/^/| /' conftest.$ac_ext >&5
     8396
     8397  # Passes both tests.
     8398ac_preproc_ok=:
     8399break
     8400fi
     8401
     8402rm -f conftest.err conftest.$ac_ext
     8403
     8404done
     8405# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
     8406rm -f conftest.err conftest.$ac_ext
     8407if $ac_preproc_ok; then
     8408  :
     8409else
     8410  { { $as_echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
     8411See \`config.log' for more details." >&5
     8412$as_echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
     8413See \`config.log' for more details." >&2;}
     8414   { (exit 1); exit 1; }; }
     8415fi
     8416
     8417ac_ext=c
     8418ac_cpp='$CPP $CPPFLAGS'
     8419ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     8420ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     8421ac_compiler_gnu=$ac_cv_c_compiler_gnu
     8422
     8423ac_ext=cpp
     8424ac_cpp='$CXXCPP $CPPFLAGS'
     8425ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     8426ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     8427ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
     8428if test -z "$CXX"; then
     8429  if test -n "$CCC"; then
     8430    CXX=$CCC
     8431  else
     8432    if test -n "$ac_tool_prefix"; then
     8433  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
     8434  do
     8435    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     8436set dummy $ac_tool_prefix$ac_prog; ac_word=$2
     8437{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     8438$as_echo_n "checking for $ac_word... " >&6; }
     8439if test "${ac_cv_prog_CXX+set}" = set; then
     8440  $as_echo_n "(cached) " >&6
     8441else
     8442  if test -n "$CXX"; then
     8443  ac_cv_prog_CXX="$CXX" # Let the user override the test.
     8444else
     8445as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     8446for as_dir in $PATH
     8447do
     8448  IFS=$as_save_IFS
     8449  test -z "$as_dir" && as_dir=.
     8450  for ac_exec_ext in '' $ac_executable_extensions; do
     8451  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     8452    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
     8453    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     8454    break 2
     8455  fi
     8456done
     8457done
     8458IFS=$as_save_IFS
     8459
     8460fi
     8461fi
     8462CXX=$ac_cv_prog_CXX
     8463if test -n "$CXX"; then
     8464  { $as_echo "$as_me:$LINENO: result: $CXX" >&5
     8465$as_echo "$CXX" >&6; }
     8466else
     8467  { $as_echo "$as_me:$LINENO: result: no" >&5
     8468$as_echo "no" >&6; }
     8469fi
     8470
     8471
     8472    test -n "$CXX" && break
     8473  done
     8474fi
     8475if test -z "$CXX"; then
     8476  ac_ct_CXX=$CXX
     8477  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
     8478do
     8479  # Extract the first word of "$ac_prog", so it can be a program name with args.
     8480set dummy $ac_prog; ac_word=$2
     8481{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
     8482$as_echo_n "checking for $ac_word... " >&6; }
     8483if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
     8484  $as_echo_n "(cached) " >&6
     8485else
     8486  if test -n "$ac_ct_CXX"; then
     8487  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
     8488else
     8489as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     8490for as_dir in $PATH
     8491do
     8492  IFS=$as_save_IFS
     8493  test -z "$as_dir" && as_dir=.
     8494  for ac_exec_ext in '' $ac_executable_extensions; do
     8495  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
     8496    ac_cv_prog_ac_ct_CXX="$ac_prog"
     8497    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
     8498    break 2
     8499  fi
     8500done
     8501done
     8502IFS=$as_save_IFS
     8503
     8504fi
     8505fi
     8506ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
     8507if test -n "$ac_ct_CXX"; then
     8508  { $as_echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
     8509$as_echo "$ac_ct_CXX" >&6; }
     8510else
     8511  { $as_echo "$as_me:$LINENO: result: no" >&5
     8512$as_echo "no" >&6; }
     8513fi
     8514
     8515
     8516  test -n "$ac_ct_CXX" && break
     8517done
     8518
     8519  if test "x$ac_ct_CXX" = x; then
     8520    CXX="g++"
     8521  else
     8522    case $cross_compiling:$ac_tool_warned in
     8523yes:)
     8524{ $as_echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools
     8525whose name does not start with the host triplet.  If you think this
     8526configuration is useful to you, please write to autoconf@gnu.org." >&5
     8527$as_echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools
     8528whose name does not start with the host triplet.  If you think this
     8529configuration is useful to you, please write to autoconf@gnu.org." >&2;}
     8530ac_tool_warned=yes ;;
     8531esac
     8532    CXX=$ac_ct_CXX
     8533  fi
     8534fi
     8535
     8536  fi
     8537fi
     8538# Provide some information about the compiler.
     8539$as_echo "$as_me:$LINENO: checking for C++ compiler version" >&5
     8540set X $ac_compile
     8541ac_compiler=$2
     8542{ (ac_try="$ac_compiler --version >&5"
     8543case "(($ac_try" in
     8544  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8545  *) ac_try_echo=$ac_try;;
     8546esac
     8547eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8548$as_echo "$ac_try_echo") >&5
     8549  (eval "$ac_compiler --version >&5") 2>&5
     8550  ac_status=$?
     8551  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8552  (exit $ac_status); }
     8553{ (ac_try="$ac_compiler -v >&5"
     8554case "(($ac_try" in
     8555  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8556  *) ac_try_echo=$ac_try;;
     8557esac
     8558eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8559$as_echo "$ac_try_echo") >&5
     8560  (eval "$ac_compiler -v >&5") 2>&5
     8561  ac_status=$?
     8562  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8563  (exit $ac_status); }
     8564{ (ac_try="$ac_compiler -V >&5"
     8565case "(($ac_try" in
     8566  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8567  *) ac_try_echo=$ac_try;;
     8568esac
     8569eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8570$as_echo "$ac_try_echo") >&5
     8571  (eval "$ac_compiler -V >&5") 2>&5
     8572  ac_status=$?
     8573  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8574  (exit $ac_status); }
     8575
     8576{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
     8577$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
     8578if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
     8579  $as_echo_n "(cached) " >&6
     8580else
     8581  cat >conftest.$ac_ext <<_ACEOF
     8582/* confdefs.h.  */
     8583_ACEOF
     8584cat confdefs.h >>conftest.$ac_ext
     8585cat >>conftest.$ac_ext <<_ACEOF
     8586/* end confdefs.h.  */
     8587
     8588int
     8589main ()
     8590{
     8591#ifndef __GNUC__
     8592       choke me
     8593#endif
     8594
     8595  ;
     8596  return 0;
     8597}
     8598_ACEOF
     8599rm -f conftest.$ac_objext
     8600if { (ac_try="$ac_compile"
     8601case "(($ac_try" in
     8602  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8603  *) ac_try_echo=$ac_try;;
     8604esac
     8605eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8606$as_echo "$ac_try_echo") >&5
     8607  (eval "$ac_compile") 2>conftest.er1
     8608  ac_status=$?
     8609  grep -v '^ *+' conftest.er1 >conftest.err
     8610  rm -f conftest.er1
     8611  cat conftest.err >&5
     8612  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8613  (exit $ac_status); } && {
     8614         test -z "$ac_cxx_werror_flag" ||
     8615         test ! -s conftest.err
     8616       } && test -s conftest.$ac_objext; then
     8617  ac_compiler_gnu=yes
     8618else
     8619  $as_echo "$as_me: failed program was:" >&5
     8620sed 's/^/| /' conftest.$ac_ext >&5
     8621
     8622        ac_compiler_gnu=no
     8623fi
     8624
     8625rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8626ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
     8627
     8628fi
     8629{ $as_echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
     8630$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
     8631if test $ac_compiler_gnu = yes; then
     8632  GXX=yes
     8633else
     8634  GXX=
     8635fi
     8636ac_test_CXXFLAGS=${CXXFLAGS+set}
     8637ac_save_CXXFLAGS=$CXXFLAGS
     8638{ $as_echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
     8639$as_echo_n "checking whether $CXX accepts -g... " >&6; }
     8640if test "${ac_cv_prog_cxx_g+set}" = set; then
     8641  $as_echo_n "(cached) " >&6
     8642else
     8643  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
     8644   ac_cxx_werror_flag=yes
     8645   ac_cv_prog_cxx_g=no
     8646   CXXFLAGS="-g"
     8647   cat >conftest.$ac_ext <<_ACEOF
     8648/* confdefs.h.  */
     8649_ACEOF
     8650cat confdefs.h >>conftest.$ac_ext
     8651cat >>conftest.$ac_ext <<_ACEOF
     8652/* end confdefs.h.  */
     8653
     8654int
     8655main ()
     8656{
     8657
     8658  ;
     8659  return 0;
     8660}
     8661_ACEOF
     8662rm -f conftest.$ac_objext
     8663if { (ac_try="$ac_compile"
     8664case "(($ac_try" in
     8665  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8666  *) ac_try_echo=$ac_try;;
     8667esac
     8668eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8669$as_echo "$ac_try_echo") >&5
     8670  (eval "$ac_compile") 2>conftest.er1
     8671  ac_status=$?
     8672  grep -v '^ *+' conftest.er1 >conftest.err
     8673  rm -f conftest.er1
     8674  cat conftest.err >&5
     8675  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8676  (exit $ac_status); } && {
     8677         test -z "$ac_cxx_werror_flag" ||
     8678         test ! -s conftest.err
     8679       } && test -s conftest.$ac_objext; then
     8680  ac_cv_prog_cxx_g=yes
     8681else
     8682  $as_echo "$as_me: failed program was:" >&5
     8683sed 's/^/| /' conftest.$ac_ext >&5
     8684
     8685        CXXFLAGS=""
     8686      cat >conftest.$ac_ext <<_ACEOF
     8687/* confdefs.h.  */
     8688_ACEOF
     8689cat confdefs.h >>conftest.$ac_ext
     8690cat >>conftest.$ac_ext <<_ACEOF
     8691/* end confdefs.h.  */
     8692
     8693int
     8694main ()
     8695{
     8696
     8697  ;
     8698  return 0;
     8699}
     8700_ACEOF
     8701rm -f conftest.$ac_objext
     8702if { (ac_try="$ac_compile"
     8703case "(($ac_try" in
     8704  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8705  *) ac_try_echo=$ac_try;;
     8706esac
     8707eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8708$as_echo "$ac_try_echo") >&5
     8709  (eval "$ac_compile") 2>conftest.er1
     8710  ac_status=$?
     8711  grep -v '^ *+' conftest.er1 >conftest.err
     8712  rm -f conftest.er1
     8713  cat conftest.err >&5
     8714  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8715  (exit $ac_status); } && {
     8716         test -z "$ac_cxx_werror_flag" ||
     8717         test ! -s conftest.err
     8718       } && test -s conftest.$ac_objext; then
     8719  :
     8720else
     8721  $as_echo "$as_me: failed program was:" >&5
     8722sed 's/^/| /' conftest.$ac_ext >&5
     8723
     8724        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
     8725         CXXFLAGS="-g"
     8726         cat >conftest.$ac_ext <<_ACEOF
     8727/* confdefs.h.  */
     8728_ACEOF
     8729cat confdefs.h >>conftest.$ac_ext
     8730cat >>conftest.$ac_ext <<_ACEOF
     8731/* end confdefs.h.  */
     8732
     8733int
     8734main ()
     8735{
     8736
     8737  ;
     8738  return 0;
     8739}
     8740_ACEOF
     8741rm -f conftest.$ac_objext
     8742if { (ac_try="$ac_compile"
     8743case "(($ac_try" in
     8744  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
     8745  *) ac_try_echo=$ac_try;;
     8746esac
     8747eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
     8748$as_echo "$ac_try_echo") >&5
     8749  (eval "$ac_compile") 2>conftest.er1
     8750  ac_status=$?
     8751  grep -v '^ *+' conftest.er1 >conftest.err
     8752  rm -f conftest.er1
     8753  cat conftest.err >&5
     8754  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
     8755  (exit $ac_status); } && {
     8756         test -z "$ac_cxx_werror_flag" ||
     8757         test ! -s conftest.err
     8758       } && test -s conftest.$ac_objext; then
     8759  ac_cv_prog_cxx_g=yes
     8760else
     8761  $as_echo "$as_me: failed program was:" >&5
     8762sed 's/^/| /' conftest.$ac_ext >&5
     8763
     8764
     8765fi
     8766
     8767rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8768fi
     8769
     8770rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8771fi
     8772
     8773rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
     8774   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
     8775fi
     8776{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
     8777$as_echo "$ac_cv_prog_cxx_g" >&6; }
     8778if test "$ac_test_CXXFLAGS" = set; then
     8779  CXXFLAGS=$ac_save_CXXFLAGS
     8780elif test $ac_cv_prog_cxx_g = yes; then
     8781  if test "$GXX" = yes; then
     8782    CXXFLAGS="-g -O2"
     8783  else
     8784    CXXFLAGS="-g"
     8785  fi
     8786else
     8787  if test "$GXX" = yes; then
     8788    CXXFLAGS="-O2"
     8789  else
     8790    CXXFLAGS=
     8791  fi
     8792fi
     8793ac_ext=c
     8794ac_cpp='$CPP $CPPFLAGS'
     8795ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
     8796ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
     8797ac_compiler_gnu=$ac_cv_c_compiler_gnu
    72218798
    72228799#-----------------------------------------------------------------------
     
    72788855
    72798856
    7280     vars="-Ipgapack/pgapack/include"
     8857    vars="-I\$(srcdir)/pgapack/pgapack/include"
    72818858    for i in $vars; do
    72828859        PKG_INCLUDES="$PKG_INCLUDES $i"
     
    1080912386
    1081012387
    10811 #AC_CONFIG_SUBDIRS( [pgapack/gekco/pgapack] )
     12388
     12389
     12390subdirs="$subdirs pgapack"
     12391
     12392
    1081212393#--------------------------------------------------------------------
    1081312394# Finally, substitute all of the various values into the Makefile.
     
    1192313504  $ac_cs_success || { (exit 1); exit 1; }
    1192413505fi
     13506
     13507#
     13508# CONFIG_SUBDIRS section.
     13509#
     13510if test "$no_recursion" != yes; then
     13511
     13512  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
     13513  # so they do not pile up.
     13514  ac_sub_configure_args=
     13515  ac_prev=
     13516  eval "set x $ac_configure_args"
     13517  shift
     13518  for ac_arg
     13519  do
     13520    if test -n "$ac_prev"; then
     13521      ac_prev=
     13522      continue
     13523    fi
     13524    case $ac_arg in
     13525    -cache-file | --cache-file | --cache-fil | --cache-fi \
     13526    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
     13527      ac_prev=cache_file ;;
     13528    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
     13529    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
     13530    | --c=*)
     13531      ;;
     13532    --config-cache | -C)
     13533      ;;
     13534    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
     13535      ac_prev=srcdir ;;
     13536    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
     13537      ;;
     13538    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
     13539      ac_prev=prefix ;;
     13540    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
     13541      ;;
     13542    --disable-option-checking)
     13543      ;;
     13544    *)
     13545      case $ac_arg in
     13546      *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
     13547      esac
     13548      ac_sub_configure_args="$ac_sub_configure_args '$ac_arg'" ;;
     13549    esac
     13550  done
     13551
     13552  # Always prepend --prefix to ensure using the same prefix
     13553  # in subdir configurations.
     13554  ac_arg="--prefix=$prefix"
     13555  case $ac_arg in
     13556  *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
     13557  esac
     13558  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
     13559
     13560  # Pass --silent
     13561  if test "$silent" = yes; then
     13562    ac_sub_configure_args="--silent $ac_sub_configure_args"
     13563  fi
     13564
     13565  # Always prepend --disable-option-checking to silence warnings, since
     13566  # different subdirs can have different --enable and --with options.
     13567  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
     13568
     13569  ac_popdir=`pwd`
     13570  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
     13571
     13572    # Do not complain, so a configure script can configure whichever
     13573    # parts of a large source tree are present.
     13574    test -d "$srcdir/$ac_dir" || continue
     13575
     13576    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
     13577    $as_echo "$as_me:$LINENO: $ac_msg" >&5
     13578    $as_echo "$ac_msg" >&6
     13579    { as_dir="$ac_dir"
     13580  case $as_dir in #(
     13581  -*) as_dir=./$as_dir;;
     13582  esac
     13583  test -d "$as_dir" || { $as_mkdir_p && mkdir -p "$as_dir"; } || {
     13584    as_dirs=
     13585    while :; do
     13586      case $as_dir in #(
     13587      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
     13588      *) as_qdir=$as_dir;;
     13589      esac
     13590      as_dirs="'$as_qdir' $as_dirs"
     13591      as_dir=`$as_dirname -- "$as_dir" ||
     13592$as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
     13593         X"$as_dir" : 'X\(//\)[^/]' \| \
     13594         X"$as_dir" : 'X\(//\)$' \| \
     13595         X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
     13596$as_echo X"$as_dir" |
     13597    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
     13598            s//\1/
     13599            q
     13600          }
     13601          /^X\(\/\/\)[^/].*/{
     13602            s//\1/
     13603            q
     13604          }
     13605          /^X\(\/\/\)$/{
     13606            s//\1/
     13607            q
     13608          }
     13609          /^X\(\/\).*/{
     13610            s//\1/
     13611            q
     13612          }
     13613          s/.*/./; q'`
     13614      test -d "$as_dir" && break
     13615    done
     13616    test -z "$as_dirs" || eval "mkdir $as_dirs"
     13617  } || test -d "$as_dir" || { { $as_echo "$as_me:$LINENO: error: cannot create directory $as_dir" >&5
     13618$as_echo "$as_me: error: cannot create directory $as_dir" >&2;}
     13619   { (exit 1); exit 1; }; }; }
     13620    ac_builddir=.
     13621
     13622case "$ac_dir" in
     13623.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
     13624*)
     13625  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
     13626  # A ".." for each directory in $ac_dir_suffix.
     13627  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
     13628  case $ac_top_builddir_sub in
     13629  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
     13630  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
     13631  esac ;;
     13632esac
     13633ac_abs_top_builddir=$ac_pwd
     13634ac_abs_builddir=$ac_pwd$ac_dir_suffix
     13635# for backward compatibility:
     13636ac_top_builddir=$ac_top_build_prefix
     13637
     13638case $srcdir in
     13639  .)  # We are building in place.
     13640    ac_srcdir=.
     13641    ac_top_srcdir=$ac_top_builddir_sub
     13642    ac_abs_top_srcdir=$ac_pwd ;;
     13643  [\\/]* | ?:[\\/]* )  # Absolute name.
     13644    ac_srcdir=$srcdir$ac_dir_suffix;
     13645    ac_top_srcdir=$srcdir
     13646    ac_abs_top_srcdir=$srcdir ;;
     13647  *) # Relative name.
     13648    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
     13649    ac_top_srcdir=$ac_top_build_prefix$srcdir
     13650    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
     13651esac
     13652ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
     13653
     13654
     13655    cd "$ac_dir"
     13656
     13657    # Check for guested configure; otherwise get Cygnus style configure.
     13658    if test -f "$ac_srcdir/configure.gnu"; then
     13659      ac_sub_configure=$ac_srcdir/configure.gnu
     13660    elif test -f "$ac_srcdir/configure"; then
     13661      ac_sub_configure=$ac_srcdir/configure
     13662    elif test -f "$ac_srcdir/configure.in"; then
     13663      # This should be Cygnus configure.
     13664      ac_sub_configure=$ac_aux_dir/configure
     13665    else
     13666      { $as_echo "$as_me:$LINENO: WARNING: no configuration information is in $ac_dir" >&5
     13667$as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
     13668      ac_sub_configure=
     13669    fi
     13670
     13671    # The recursion is here.
     13672    if test -n "$ac_sub_configure"; then
     13673      # Make the cache file name correct relative to the subdirectory.
     13674      case $cache_file in
     13675      [\\/]* | ?:[\\/]* ) ac_sub_cache_file=$cache_file ;;
     13676      *) # Relative name.
     13677        ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
     13678      esac
     13679
     13680      { $as_echo "$as_me:$LINENO: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5
     13681$as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
     13682      # The eval makes quoting arguments work.
     13683      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
     13684           --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
     13685        { { $as_echo "$as_me:$LINENO: error: $ac_sub_configure failed for $ac_dir" >&5
     13686$as_echo "$as_me: error: $ac_sub_configure failed for $ac_dir" >&2;}
     13687   { (exit 1); exit 1; }; }
     13688    fi
     13689
     13690    cd "$ac_popdir"
     13691  done
     13692fi
    1192513693if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
    1192613694  { $as_echo "$as_me:$LINENO: WARNING: Unrecognized options: $ac_unrecognized_opts" >&5
Note: See TracChangeset for help on using the changeset viewer.