Changeset 3675 for ThirdParty/Glpk


Ignore:
Timestamp:
Sep 7, 2016 11:27:44 AM (3 years ago)
Author:
stefan
Message:

adjust to buildtools changes and rerun autotools

Location:
ThirdParty/Glpk/branches/autotools-update
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • ThirdParty/Glpk/branches/autotools-update/configure

    r3670 r3675  
    670670GREP
    671671SED
     672host_os
     673host_vendor
     674host_cpu
     675host
     676LIBTOOL
    672677am__fastdepCC_FALSE
    673678am__fastdepCC_TRUE
     
    687692CFLAGS
    688693CC
    689 host_os
    690 host_vendor
    691 host_cpu
    692 host
    693 LIBTOOL
    694694MAINT
    695695MAINTAINER_MODE_FALSE
     
    774774enable_silent_rules
    775775enable_maintainer_mode
     776enable_dependency_tracking
    776777enable_static
    777778enable_shared
     
    779780enable_fast_install
    780781with_aix_soname
    781 enable_dependency_tracking
    782782with_gnu_ld
    783783with_sysroot
     
    14221422                          enable make rules and dependencies not useful (and
    14231423                          sometimes confusing) to the casual installer
     1424  --enable-dependency-tracking
     1425                          do not reject slow dependency extractors
     1426  --disable-dependency-tracking
     1427                          speeds up one-time build
    14241428  --enable-static[=PKGS]  build static libraries [default=no]
    14251429  --enable-shared[=PKGS]  build shared libraries [default=yes]
    14261430  --enable-fast-install[=PKGS]
    14271431                          optimize for fast installation [default=yes]
    1428   --enable-dependency-tracking
    1429                           do not reject slow dependency extractors
    1430   --disable-dependency-tracking
    1431                           speeds up one-time build
    14321432  --disable-libtool-lock  avoid locking (might break parallel builds)
    14331433  --disable-gmp           do not compile with GNU multiple precision library
     
    22652265
    22662266
    2267   if test "$enable_msvc" = yes; then
    2268     case $build in
    2269       *-cygwin* | *-mingw* | *-msys*) ;;
    2270       *) as_fn_error $? "--enable-msvc option makes sense only under Cygwin or MinGW or MSys" "$LINENO" 5 ;;
    2271     esac
    2272   fi
    2273 
    22742267
    22752268# we want --enable-msvc setup and checked
     
    22882281  : ${FFLAGS:=""}
    22892282  : ${FCFLAGS:=""}
    2290   : ${CFLAGS:="-DNDEBUG -EHsc"}
    2291   : ${CXXFLAGS:="-DNDEBUG -EHsc"}
     2283  : ${CFLAGS:="-DNDEBUG -nologo"}
     2284  : ${CXXFLAGS:="-DNDEBUG -EHsc -nologo"}
    22922285else
    22932286  : ${FFLAGS:=""}
     
    28282821AM_BACKSLASH='\'
    28292822
    2830 case `pwd` in
    2831   *\ * | *\     *)
    2832     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
    2833 $as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
     2823
     2824# required autoconf version
     2825
     2826
     2827# Set the project's version numbers
     2828
     2829
     2830cat >>confdefs.h <<_ACEOF
     2831#define GLPK_VERSION "$PACKAGE_VERSION"
     2832_ACEOF
     2833
     2834
     2835  coin_majorver=`echo $PACKAGE_VERSION | sed -n -e 's/^\([0-9]*\).*/\1/gp'`
     2836  coin_minorver=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.\([0-9]*\).*/\1/gp'`
     2837  coin_releasever=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/gp'`
     2838  test -z "$coin_majorver"   && coin_majorver=9999
     2839  test -z "$coin_minorver"   && coin_minorver=9999
     2840  test -z "$coin_releasever" && coin_releasever=9999
     2841
     2842cat >>confdefs.h <<_ACEOF
     2843#define GLPK_VERSION_MAJOR $coin_majorver
     2844_ACEOF
     2845
     2846
     2847cat >>confdefs.h <<_ACEOF
     2848#define GLPK_VERSION_MINOR $coin_minorver
     2849_ACEOF
     2850
     2851
     2852cat >>confdefs.h <<_ACEOF
     2853#define GLPK_VERSION_RELEASE $coin_releasever
     2854_ACEOF
     2855
     2856
     2857  # We use the following variable to have a string with the upper case
     2858  # version of the project name
     2859  COIN_PRJCT=GLPK
     2860
     2861  # Set the project's SVN revision number. The complicated sed expression
     2862  # (made worse by quadrigraphs) ensures that things like 4123:4168MS end up
     2863  # as a single number.
     2864  # Extract the first word of "svnversion", so it can be a program name with args.
     2865set dummy svnversion; ac_word=$2
     2866{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
     2867$as_echo_n "checking for $ac_word... " >&6; }
     2868if ${ac_cv_prog_have_svnversion+:} false; then :
     2869  $as_echo_n "(cached) " >&6
     2870else
     2871  if test -n "$have_svnversion"; then
     2872  ac_cv_prog_have_svnversion="$have_svnversion" # Let the user override the test.
     2873else
     2874as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
     2875for as_dir in $PATH
     2876do
     2877  IFS=$as_save_IFS
     2878  test -z "$as_dir" && as_dir=.
     2879    for ac_exec_ext in '' $ac_executable_extensions; do
     2880  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
     2881    ac_cv_prog_have_svnversion="yes"
     2882    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     2883    break 2
     2884  fi
     2885done
     2886  done
     2887IFS=$as_save_IFS
     2888
     2889  test -z "$ac_cv_prog_have_svnversion" && ac_cv_prog_have_svnversion="no"
     2890fi
     2891fi
     2892have_svnversion=$ac_cv_prog_have_svnversion
     2893if test -n "$have_svnversion"; then
     2894  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_svnversion" >&5
     2895$as_echo "$have_svnversion" >&6; }
     2896else
     2897  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
     2898$as_echo "no" >&6; }
     2899fi
     2900
     2901
     2902  if test "x$have_svnversion" = xyes; then
     2903
     2904    svn_rev_tmp=`LANG=en_EN svnversion $srcdir 2>/dev/null`
     2905    if test "x$svn_rev_tmp" != xexported -a "x$svn_rev_tmp" != x -a "x$svn_rev_tmp" != "xUnversioned directory"; then
     2906      GLPK_SVN_REV=`echo $svn_rev_tmp | sed -n -e 's/^[0-9]*://' -e 's/\([0-9]\)[^0-9]*$/\1/p'`
     2907
     2908cat >>confdefs.h <<_ACEOF
     2909#define GLPK_SVN_REV $GLPK_SVN_REV
     2910_ACEOF
     2911
     2912    fi
     2913  fi
     2914
     2915
     2916
     2917# Capture libtool library version, if given.
     2918
     2919
     2920
     2921# A useful makefile conditional that is always false
     2922 if false; then
     2923  ALWAYS_FALSE_TRUE=
     2924  ALWAYS_FALSE_FALSE='#'
     2925else
     2926  ALWAYS_FALSE_TRUE='#'
     2927  ALWAYS_FALSE_FALSE=
     2928fi
     2929
     2930
     2931# Where should everything be installed by default?  Here, we want it
     2932# to be installed directly in 'bin', 'lib', 'include' subdirectories
     2933# of the directory where configure is run.  The default would be
     2934# /usr/local.
     2935
     2936
     2937# change default compiler flags; this needs to run very early (before AC_CANONICAL_BUILD)
     2938
     2939
     2940# Get the system type
     2941
     2942
     2943# initialize automake
     2944# - don't define PACKAGE or VERSION
     2945# - disable dist target
     2946# - enable all automake warnings
     2947if test "`cd $srcdir && pwd`" != "`pwd`"; then
     2948  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
     2949  # is not polluted with repeated "-I."
     2950  am__isrc=' -I$(srcdir)'
     2951  # test to see if srcdir already configured
     2952  if test -f $srcdir/config.status; then
     2953    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
     2954  fi
     2955fi
     2956
     2957# test whether we have cygpath
     2958if test -z "$CYGPATH_W"; then
     2959  if (cygpath --version) >/dev/null 2>/dev/null; then
     2960    CYGPATH_W='cygpath -w'
     2961  else
     2962    CYGPATH_W=echo
     2963  fi
     2964fi
     2965
     2966
     2967# Define the identity of the package.
     2968 PACKAGE='thirdpartyglpk'
     2969 VERSION='trunk'
     2970
     2971
     2972# Some tools Automake needs.
     2973
     2974ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
     2975
     2976
     2977AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
     2978
     2979
     2980AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
     2981
     2982
     2983AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
     2984
     2985
     2986MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
     2987
     2988# For better backward compatibility.  To be removed once Automake 1.9.x
     2989# dies out for good.  For more background, see:
     2990# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
     2991# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
     2992mkdir_p='$(MKDIR_P)'
     2993
     2994# We need awk for the "check" target (and possibly the TAP driver).  The
     2995# system "awk" is bad on some platforms.
     2996# Always define AMTAR for backward compatibility.  Yes, it's still used
     2997# in the wild :-(  We should find a proper way to deprecate it ...
     2998AMTAR='$${TAR-tar}'
     2999
     3000
     3001# We'll loop over all known methods to create a tar archive until one works.
     3002_am_tools='gnutar  pax cpio none'
     3003
     3004am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
     3005
     3006
     3007
     3008
     3009
     3010
     3011# POSIX will say in a future version that running "rm -f" with no argument
     3012# is OK; and we want to be able to make that assumption in our Makefile
     3013# recipes.  So use an aggressive probe to check that the usage we want is
     3014# actually supported "in the wild" to an acceptable degree.
     3015# See automake bug#10828.
     3016# To make any issue more visible, cause the running configure to be aborted
     3017# by default if the 'rm' program in use doesn't match our expectations; the
     3018# user can still override this though.
     3019if rm -f && rm -fr && rm -rf; then : OK; else
     3020  cat >&2 <<'END'
     3021Oops!
     3022
     3023Your 'rm' program seems unable to run without file operands specified
     3024on the command line, even when the '-f' option is present.  This is contrary
     3025to the behaviour of most rm programs out there, and not conforming with
     3026the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
     3027
     3028Please tell bug-automake@gnu.org about your system, including the value
     3029of your $PATH and any error possibly output before this message.  This
     3030can help us improve future automake versions.
     3031
     3032END
     3033  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
     3034    echo 'Configuration will proceed anyway, since you have set the' >&2
     3035    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
     3036    echo >&2
     3037  else
     3038    cat >&2 <<'END'
     3039Aborting the configuration process, to ensure you take notice of the issue.
     3040
     3041You can download and install GNU coreutils to get an 'rm' implementation
     3042that behaves properly: <http://www.gnu.org/software/coreutils/>.
     3043
     3044If you want to complete the configuration process using your problematic
     3045'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
     3046to "yes", and re-run configure.
     3047
     3048END
     3049    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
     3050  fi
     3051fi
     3052
     3053
     3054# make silent build rules the default (https://www.gnu.org/software/automake/manual/html_node/Automake-Silent-Rules.html)
     3055# Check whether --enable-silent-rules was given.
     3056if test "${enable_silent_rules+set}" = set; then :
     3057  enableval=$enable_silent_rules;
     3058fi
     3059
     3060case $enable_silent_rules in # (((
     3061  yes) AM_DEFAULT_VERBOSITY=0;;
     3062   no) AM_DEFAULT_VERBOSITY=1;;
     3063    *) AM_DEFAULT_VERBOSITY=0;;
    28343064esac
    2835 
    2836 
    2837 
    2838 macro_version='2.4.6'
    2839 macro_revision='2.4.6'
    2840 
    2841 
    2842 
    2843 
    2844 
    2845 
    2846 
    2847 
    2848 
    2849 
    2850 
    2851 
    2852 
    2853 ltmain=$ac_aux_dir/ltmain.sh
    2854 
    2855 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
    2856 $as_echo_n "checking host system type... " >&6; }
    2857 if ${ac_cv_host+:} false; then :
     3065am_make=${MAKE-make}
     3066{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
     3067$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
     3068if ${am_cv_make_support_nested_variables+:} false; then :
    28583069  $as_echo_n "(cached) " >&6
    28593070else
    2860   if test "x$host_alias" = x; then
    2861   ac_cv_host=$ac_cv_build
    2862 else
    2863   ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
    2864     as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
    2865 fi
    2866 
    2867 fi
    2868 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
    2869 $as_echo "$ac_cv_host" >&6; }
    2870 case $ac_cv_host in
    2871 *-*-*) ;;
    2872 *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
    2873 esac
    2874 host=$ac_cv_host
    2875 ac_save_IFS=$IFS; IFS='-'
    2876 set x $ac_cv_host
    2877 shift
    2878 host_cpu=$1
    2879 host_vendor=$2
    2880 shift; shift
    2881 # Remember, the first character of IFS is used to create $*,
    2882 # except with old shells:
    2883 host_os=$*
    2884 IFS=$ac_save_IFS
    2885 case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
    2886 
    2887 
    2888 # Backslashify metacharacters that are still active within
    2889 # double-quoted strings.
    2890 sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
    2891 
    2892 # Same as above, but do not quote variable references.
    2893 double_quote_subst='s/\(["`\\]\)/\\\1/g'
    2894 
    2895 # Sed substitution to delay expansion of an escaped shell variable in a
    2896 # double_quote_subst'ed string.
    2897 delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
    2898 
    2899 # Sed substitution to delay expansion of an escaped single quote.
    2900 delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
    2901 
    2902 # Sed substitution to avoid accidental globbing in evaled expressions
    2903 no_glob_subst='s/\*/\\\*/g'
    2904 
    2905 ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
    2906 ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
    2907 ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
    2908 
    2909 { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
    2910 $as_echo_n "checking how to print strings... " >&6; }
    2911 # Test print first, because it will be a builtin if present.
    2912 if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
    2913    test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
    2914   ECHO='print -r --'
    2915 elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
    2916   ECHO='printf %s\n'
    2917 else
    2918   # Use this function as a fallback that always works.
    2919   func_fallback_echo ()
    2920   {
    2921     eval 'cat <<_LTECHO_EOF
    2922 $1
    2923 _LTECHO_EOF'
    2924   }
    2925   ECHO='func_fallback_echo'
    2926 fi
    2927 
    2928 # func_echo_all arg...
    2929 # Invoke $ECHO with all args, space-separated.
    2930 func_echo_all ()
    2931 {
    2932     $ECHO ""
    2933 }
    2934 
    2935 case $ECHO in
    2936   printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
    2937 $as_echo "printf" >&6; } ;;
    2938   print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
    2939 $as_echo "print -r" >&6; } ;;
    2940   *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
    2941 $as_echo "cat" >&6; } ;;
    2942 esac
    2943 
    2944 
    2945 
    2946 
    2947 
    2948 
    2949 
    2950 
    2951 
    2952 
    2953 
    2954 
    2955 
    2956 
     3071  if $as_echo 'TRUE=$(BAR$(V))
     3072BAR0=false
     3073BAR1=true
     3074V=1
     3075am__doit:
     3076        @$(TRUE)
     3077.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
     3078  am_cv_make_support_nested_variables=yes
     3079else
     3080  am_cv_make_support_nested_variables=no
     3081fi
     3082fi
     3083{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
     3084$as_echo "$am_cv_make_support_nested_variables" >&6; }
     3085if test $am_cv_make_support_nested_variables = yes; then
     3086    AM_V='$(V)'
     3087  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
     3088else
     3089  AM_V=$AM_DEFAULT_VERBOSITY
     3090  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
     3091fi
     3092AM_BACKSLASH='\'
     3093
     3094
     3095# disable automatic rebuild of configure/Makefile
     3096
     3097{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
     3098$as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
     3099    # Check whether --enable-maintainer-mode was given.
     3100if test "${enable_maintainer_mode+set}" = set; then :
     3101  enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
     3102else
     3103  USE_MAINTAINER_MODE=no
     3104fi
     3105
     3106  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
     3107$as_echo "$USE_MAINTAINER_MODE" >&6; }
     3108   if test $USE_MAINTAINER_MODE = yes; then
     3109  MAINTAINER_MODE_TRUE=
     3110  MAINTAINER_MODE_FALSE='#'
     3111else
     3112  MAINTAINER_MODE_TRUE='#'
     3113  MAINTAINER_MODE_FALSE=
     3114fi
     3115
     3116  MAINT=$MAINTAINER_MODE_TRUE
     3117
     3118
     3119
     3120
     3121#############################################################################
     3122#                         Standard build tool stuff                         #
     3123#############################################################################
     3124
     3125# Get the name of the C compiler
    29573126DEPDIR="${am__leading_dot}deps"
    29583127
     
    30183187
    30193188
     3189
     3190
     3191# setting up libtool invokes AC_PROG_CC, but as we may want to change the
     3192# order of compilers, we want to invoke it from this macro first
     3193
     3194
     3195
     3196# if enable-msvc, then test only for MS and Intel (on Windows) C compiler
     3197# otherwise, test a long list of C compilers that comes into our mind
     3198if test $enable_msvc = yes ; then
     3199  comps="icl cl"
     3200else
     3201  # TODO old buildtools was doing some $build specific logic here, we still need this?
     3202  comps="gcc clang cc icc icl cl cc xlc xlc_r pgcc"
     3203fi
    30203204ac_ext=c
    30213205ac_cpp='$CPP $CPPFLAGS'
     
    30243208ac_compiler_gnu=$ac_cv_c_compiler_gnu
    30253209if test -n "$ac_tool_prefix"; then
    3026   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
    3027 set dummy ${ac_tool_prefix}gcc; ac_word=$2
    3028 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3029 $as_echo_n "checking for $ac_word... " >&6; }
    3030 if ${ac_cv_prog_CC+:} false; then :
    3031   $as_echo_n "(cached) " >&6
    3032 else
    3033   if test -n "$CC"; then
    3034   ac_cv_prog_CC="$CC" # Let the user override the test.
    3035 else
    3036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3037 for as_dir in $PATH
    3038 do
    3039   IFS=$as_save_IFS
    3040   test -z "$as_dir" && as_dir=.
    3041     for ac_exec_ext in '' $ac_executable_extensions; do
    3042   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3043     ac_cv_prog_CC="${ac_tool_prefix}gcc"
    3044     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3045     break 2
    3046   fi
    3047 done
    3048   done
    3049 IFS=$as_save_IFS
    3050 
    3051 fi
    3052 fi
    3053 CC=$ac_cv_prog_CC
    3054 if test -n "$CC"; then
    3055   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    3056 $as_echo "$CC" >&6; }
    3057 else
    3058   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3059 $as_echo "no" >&6; }
    3060 fi
    3061 
    3062 
    3063 fi
    3064 if test -z "$ac_cv_prog_CC"; then
    3065   ac_ct_CC=$CC
    3066   # Extract the first word of "gcc", so it can be a program name with args.
    3067 set dummy gcc; ac_word=$2
    3068 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3069 $as_echo_n "checking for $ac_word... " >&6; }
    3070 if ${ac_cv_prog_ac_ct_CC+:} false; then :
    3071   $as_echo_n "(cached) " >&6
    3072 else
    3073   if test -n "$ac_ct_CC"; then
    3074   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
    3075 else
    3076 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3077 for as_dir in $PATH
    3078 do
    3079   IFS=$as_save_IFS
    3080   test -z "$as_dir" && as_dir=.
    3081     for ac_exec_ext in '' $ac_executable_extensions; do
    3082   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3083     ac_cv_prog_ac_ct_CC="gcc"
    3084     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3085     break 2
    3086   fi
    3087 done
    3088   done
    3089 IFS=$as_save_IFS
    3090 
    3091 fi
    3092 fi
    3093 ac_ct_CC=$ac_cv_prog_ac_ct_CC
    3094 if test -n "$ac_ct_CC"; then
    3095   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
    3096 $as_echo "$ac_ct_CC" >&6; }
    3097 else
    3098   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3099 $as_echo "no" >&6; }
    3100 fi
    3101 
    3102   if test "x$ac_ct_CC" = x; then
    3103     CC=""
    3104   else
    3105     case $cross_compiling:$ac_tool_warned in
    3106 yes:)
    3107 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    3108 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    3109 ac_tool_warned=yes ;;
    3110 esac
    3111     CC=$ac_ct_CC
    3112   fi
    3113 else
    3114   CC="$ac_cv_prog_CC"
    3115 fi
    3116 
    3117 if test -z "$CC"; then
    3118           if test -n "$ac_tool_prefix"; then
    3119     # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
    3120 set dummy ${ac_tool_prefix}cc; ac_word=$2
    3121 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3122 $as_echo_n "checking for $ac_word... " >&6; }
    3123 if ${ac_cv_prog_CC+:} false; then :
    3124   $as_echo_n "(cached) " >&6
    3125 else
    3126   if test -n "$CC"; then
    3127   ac_cv_prog_CC="$CC" # Let the user override the test.
    3128 else
    3129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3130 for as_dir in $PATH
    3131 do
    3132   IFS=$as_save_IFS
    3133   test -z "$as_dir" && as_dir=.
    3134     for ac_exec_ext in '' $ac_executable_extensions; do
    3135   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3136     ac_cv_prog_CC="${ac_tool_prefix}cc"
    3137     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3138     break 2
    3139   fi
    3140 done
    3141   done
    3142 IFS=$as_save_IFS
    3143 
    3144 fi
    3145 fi
    3146 CC=$ac_cv_prog_CC
    3147 if test -n "$CC"; then
    3148   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    3149 $as_echo "$CC" >&6; }
    3150 else
    3151   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3152 $as_echo "no" >&6; }
    3153 fi
    3154 
    3155 
    3156   fi
    3157 fi
    3158 if test -z "$CC"; then
    3159   # Extract the first word of "cc", so it can be a program name with args.
    3160 set dummy cc; ac_word=$2
    3161 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    3162 $as_echo_n "checking for $ac_word... " >&6; }
    3163 if ${ac_cv_prog_CC+:} false; then :
    3164   $as_echo_n "(cached) " >&6
    3165 else
    3166   if test -n "$CC"; then
    3167   ac_cv_prog_CC="$CC" # Let the user override the test.
    3168 else
    3169   ac_prog_rejected=no
    3170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    3171 for as_dir in $PATH
    3172 do
    3173   IFS=$as_save_IFS
    3174   test -z "$as_dir" && as_dir=.
    3175     for ac_exec_ext in '' $ac_executable_extensions; do
    3176   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    3177     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
    3178        ac_prog_rejected=yes
    3179        continue
    3180      fi
    3181     ac_cv_prog_CC="cc"
    3182     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    3183     break 2
    3184   fi
    3185 done
    3186   done
    3187 IFS=$as_save_IFS
    3188 
    3189 if test $ac_prog_rejected = yes; then
    3190   # We found a bogon in the path, so make sure we never use it.
    3191   set dummy $ac_cv_prog_CC
    3192   shift
    3193   if test $# != 0; then
    3194     # We chose a different compiler from the bogus one.
    3195     # However, it has the same basename, so the bogon will be chosen
    3196     # first if we set CC to just the basename; use the full file name.
    3197     shift
    3198     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
    3199   fi
    3200 fi
    3201 fi
    3202 fi
    3203 CC=$ac_cv_prog_CC
    3204 if test -n "$CC"; then
    3205   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    3206 $as_echo "$CC" >&6; }
    3207 else
    3208   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    3209 $as_echo "no" >&6; }
    3210 fi
    3211 
    3212 
    3213 fi
    3214 if test -z "$CC"; then
    3215   if test -n "$ac_tool_prefix"; then
    3216   for ac_prog in cl.exe
     3210  for ac_prog in $comps
    32173211  do
    32183212    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
     
    32583252if test -z "$CC"; then
    32593253  ac_ct_CC=$CC
    3260   for ac_prog in cl.exe
     3254  for ac_prog in $comps
    32613255do
    32623256  # Extract the first word of "$ac_prog", so it can be a program name with args.
     
    33113305    CC=$ac_ct_CC
    33123306  fi
    3313 fi
    3314 
    33153307fi
    33163308
     
    39923984  am__fastdepCC_FALSE=
    39933985fi
     3986
     3987
     3988
     3989
     3990# Initialize libtool
     3991case `pwd` in
     3992  *\ * | *\     *)
     3993    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
     3994$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
     3995esac
     3996
     3997
     3998
     3999macro_version='2.4.6'
     4000macro_revision='2.4.6'
     4001
     4002
     4003
     4004
     4005
     4006
     4007
     4008
     4009
     4010
     4011
     4012
     4013
     4014ltmain=$ac_aux_dir/ltmain.sh
     4015
     4016{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
     4017$as_echo_n "checking host system type... " >&6; }
     4018if ${ac_cv_host+:} false; then :
     4019  $as_echo_n "(cached) " >&6
     4020else
     4021  if test "x$host_alias" = x; then
     4022  ac_cv_host=$ac_cv_build
     4023else
     4024  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
     4025    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
     4026fi
     4027
     4028fi
     4029{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
     4030$as_echo "$ac_cv_host" >&6; }
     4031case $ac_cv_host in
     4032*-*-*) ;;
     4033*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
     4034esac
     4035host=$ac_cv_host
     4036ac_save_IFS=$IFS; IFS='-'
     4037set x $ac_cv_host
     4038shift
     4039host_cpu=$1
     4040host_vendor=$2
     4041shift; shift
     4042# Remember, the first character of IFS is used to create $*,
     4043# except with old shells:
     4044host_os=$*
     4045IFS=$ac_save_IFS
     4046case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
     4047
     4048
     4049# Backslashify metacharacters that are still active within
     4050# double-quoted strings.
     4051sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
     4052
     4053# Same as above, but do not quote variable references.
     4054double_quote_subst='s/\(["`\\]\)/\\\1/g'
     4055
     4056# Sed substitution to delay expansion of an escaped shell variable in a
     4057# double_quote_subst'ed string.
     4058delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
     4059
     4060# Sed substitution to delay expansion of an escaped single quote.
     4061delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
     4062
     4063# Sed substitution to avoid accidental globbing in evaled expressions
     4064no_glob_subst='s/\*/\\\*/g'
     4065
     4066ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
     4067ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
     4068ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
     4069
     4070{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
     4071$as_echo_n "checking how to print strings... " >&6; }
     4072# Test print first, because it will be a builtin if present.
     4073if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
     4074   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
     4075  ECHO='print -r --'
     4076elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
     4077  ECHO='printf %s\n'
     4078else
     4079  # Use this function as a fallback that always works.
     4080  func_fallback_echo ()
     4081  {
     4082    eval 'cat <<_LTECHO_EOF
     4083$1
     4084_LTECHO_EOF'
     4085  }
     4086  ECHO='func_fallback_echo'
     4087fi
     4088
     4089# func_echo_all arg...
     4090# Invoke $ECHO with all args, space-separated.
     4091func_echo_all ()
     4092{
     4093    $ECHO ""
     4094}
     4095
     4096case $ECHO in
     4097  printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
     4098$as_echo "printf" >&6; } ;;
     4099  print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
     4100$as_echo "print -r" >&6; } ;;
     4101  *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
     4102$as_echo "cat" >&6; } ;;
     4103esac
     4104
     4105
     4106
     4107
     4108
     4109
     4110
     4111
     4112
     4113
     4114
     4115
    39944116
    39954117
     
    75977719
    75987720done
    7599 
    7600 
    7601 # required autoconf version
    7602 
    7603 
    7604 # Set the project's version numbers
    7605 
    7606 
    7607 cat >>confdefs.h <<_ACEOF
    7608 #define GLPK_VERSION "$PACKAGE_VERSION"
    7609 _ACEOF
    7610 
    7611 
    7612   coin_majorver=`echo $PACKAGE_VERSION | sed -n -e 's/^\([0-9]*\).*/\1/gp'`
    7613   coin_minorver=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.\([0-9]*\).*/\1/gp'`
    7614   coin_releasever=`echo $PACKAGE_VERSION | sed -n -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\).*/\1/gp'`
    7615   test -z "$coin_majorver"   && coin_majorver=9999
    7616   test -z "$coin_minorver"   && coin_minorver=9999
    7617   test -z "$coin_releasever" && coin_releasever=9999
    7618 
    7619 cat >>confdefs.h <<_ACEOF
    7620 #define GLPK_VERSION_MAJOR $coin_majorver
    7621 _ACEOF
    7622 
    7623 
    7624 cat >>confdefs.h <<_ACEOF
    7625 #define GLPK_VERSION_MINOR $coin_minorver
    7626 _ACEOF
    7627 
    7628 
    7629 cat >>confdefs.h <<_ACEOF
    7630 #define GLPK_VERSION_RELEASE $coin_releasever
    7631 _ACEOF
    7632 
    7633 
    7634   # We use the following variable to have a string with the upper case
    7635   # version of the project name
    7636   COIN_PRJCT=GLPK
    7637 
    7638   # Set the project's SVN revision number. The complicated sed expression
    7639   # (made worse by quadrigraphs) ensures that things like 4123:4168MS end up
    7640   # as a single number.
    7641   # Extract the first word of "svnversion", so it can be a program name with args.
    7642 set dummy svnversion; ac_word=$2
    7643 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    7644 $as_echo_n "checking for $ac_word... " >&6; }
    7645 if ${ac_cv_prog_have_svnversion+:} false; then :
    7646   $as_echo_n "(cached) " >&6
    7647 else
    7648   if test -n "$have_svnversion"; then
    7649   ac_cv_prog_have_svnversion="$have_svnversion" # Let the user override the test.
    7650 else
    7651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    7652 for as_dir in $PATH
    7653 do
    7654   IFS=$as_save_IFS
    7655   test -z "$as_dir" && as_dir=.
    7656     for ac_exec_ext in '' $ac_executable_extensions; do
    7657   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    7658     ac_cv_prog_have_svnversion="yes"
    7659     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    7660     break 2
    7661   fi
    7662 done
    7663   done
    7664 IFS=$as_save_IFS
    7665 
    7666   test -z "$ac_cv_prog_have_svnversion" && ac_cv_prog_have_svnversion="no"
    7667 fi
    7668 fi
    7669 have_svnversion=$ac_cv_prog_have_svnversion
    7670 if test -n "$have_svnversion"; then
    7671   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_svnversion" >&5
    7672 $as_echo "$have_svnversion" >&6; }
    7673 else
    7674   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    7675 $as_echo "no" >&6; }
    7676 fi
    7677 
    7678 
    7679   if test "x$have_svnversion" = xyes; then
    7680 
    7681     svn_rev_tmp=`LANG=en_EN svnversion $srcdir 2>/dev/null`
    7682     if test "x$svn_rev_tmp" != xexported -a "x$svn_rev_tmp" != x -a "x$svn_rev_tmp" != "xUnversioned directory"; then
    7683       GLPK_SVN_REV=`echo $svn_rev_tmp | sed -n -e 's/^[0-9]*://' -e 's/\([0-9]\)[^0-9]*$/\1/p'`
    7684 
    7685 cat >>confdefs.h <<_ACEOF
    7686 #define GLPK_SVN_REV $GLPK_SVN_REV
    7687 _ACEOF
    7688 
    7689     fi
    7690   fi
    7691 
    7692 
    7693 
    7694 # Capture libtool library version, if given.
    7695 
    7696 
    7697 
    7698 # A useful makefile conditional that is always false
    7699  if false; then
    7700   ALWAYS_FALSE_TRUE=
    7701   ALWAYS_FALSE_FALSE='#'
    7702 else
    7703   ALWAYS_FALSE_TRUE='#'
    7704   ALWAYS_FALSE_FALSE=
    7705 fi
    7706 
    7707 
    7708 # Where should everything be installed by default?  Here, we want it
    7709 # to be installed directly in 'bin', 'lib', 'include' subdirectories
    7710 # of the directory where configure is run.  The default would be
    7711 # /usr/local.
    7712 
    7713 
    7714 # change default compiler flags; this needs to run very early (before AC_CANONICAL_BUILD)
    7715 
    7716 
    7717 # Get the system type
    7718 
    7719 
    7720 # initialize automake
    7721 # - don't define PACKAGE or VERSION
    7722 # - disable dist target
    7723 # - enable all automake warnings
    7724 if test "`cd $srcdir && pwd`" != "`pwd`"; then
    7725   # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
    7726   # is not polluted with repeated "-I."
    7727   am__isrc=' -I$(srcdir)'
    7728   # test to see if srcdir already configured
    7729   if test -f $srcdir/config.status; then
    7730     as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
    7731   fi
    7732 fi
    7733 
    7734 # test whether we have cygpath
    7735 if test -z "$CYGPATH_W"; then
    7736   if (cygpath --version) >/dev/null 2>/dev/null; then
    7737     CYGPATH_W='cygpath -w'
    7738   else
    7739     CYGPATH_W=echo
    7740   fi
    7741 fi
    7742 
    7743 
    7744 # Define the identity of the package.
    7745  PACKAGE='thirdpartyglpk'
    7746  VERSION='trunk'
    7747 
    7748 
    7749 # Some tools Automake needs.
    7750 
    7751 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
    7752 
    7753 
    7754 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
    7755 
    7756 
    7757 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
    7758 
    7759 
    7760 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
    7761 
    7762 
    7763 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
    7764 
    7765 # For better backward compatibility.  To be removed once Automake 1.9.x
    7766 # dies out for good.  For more background, see:
    7767 # <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
    7768 # <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
    7769 mkdir_p='$(MKDIR_P)'
    7770 
    7771 # We need awk for the "check" target (and possibly the TAP driver).  The
    7772 # system "awk" is bad on some platforms.
    7773 # Always define AMTAR for backward compatibility.  Yes, it's still used
    7774 # in the wild :-(  We should find a proper way to deprecate it ...
    7775 AMTAR='$${TAR-tar}'
    7776 
    7777 
    7778 # We'll loop over all known methods to create a tar archive until one works.
    7779 _am_tools='gnutar  pax cpio none'
    7780 
    7781 am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
    7782 
    7783 
    7784 
    7785 
    7786 
    7787 
    7788 # POSIX will say in a future version that running "rm -f" with no argument
    7789 # is OK; and we want to be able to make that assumption in our Makefile
    7790 # recipes.  So use an aggressive probe to check that the usage we want is
    7791 # actually supported "in the wild" to an acceptable degree.
    7792 # See automake bug#10828.
    7793 # To make any issue more visible, cause the running configure to be aborted
    7794 # by default if the 'rm' program in use doesn't match our expectations; the
    7795 # user can still override this though.
    7796 if rm -f && rm -fr && rm -rf; then : OK; else
    7797   cat >&2 <<'END'
    7798 Oops!
    7799 
    7800 Your 'rm' program seems unable to run without file operands specified
    7801 on the command line, even when the '-f' option is present.  This is contrary
    7802 to the behaviour of most rm programs out there, and not conforming with
    7803 the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
    7804 
    7805 Please tell bug-automake@gnu.org about your system, including the value
    7806 of your $PATH and any error possibly output before this message.  This
    7807 can help us improve future automake versions.
    7808 
    7809 END
    7810   if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
    7811     echo 'Configuration will proceed anyway, since you have set the' >&2
    7812     echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
    7813     echo >&2
    7814   else
    7815     cat >&2 <<'END'
    7816 Aborting the configuration process, to ensure you take notice of the issue.
    7817 
    7818 You can download and install GNU coreutils to get an 'rm' implementation
    7819 that behaves properly: <http://www.gnu.org/software/coreutils/>.
    7820 
    7821 If you want to complete the configuration process using your problematic
    7822 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
    7823 to "yes", and re-run configure.
    7824 
    7825 END
    7826     as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
    7827   fi
    7828 fi
    7829 
    7830 
    7831 # make silent build rules the default (https://www.gnu.org/software/automake/manual/html_node/Automake-Silent-Rules.html)
    7832 # Check whether --enable-silent-rules was given.
    7833 if test "${enable_silent_rules+set}" = set; then :
    7834   enableval=$enable_silent_rules;
    7835 fi
    7836 
    7837 case $enable_silent_rules in # (((
    7838   yes) AM_DEFAULT_VERBOSITY=0;;
    7839    no) AM_DEFAULT_VERBOSITY=1;;
    7840     *) AM_DEFAULT_VERBOSITY=0;;
    7841 esac
    7842 am_make=${MAKE-make}
    7843 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
    7844 $as_echo_n "checking whether $am_make supports nested variables... " >&6; }
    7845 if ${am_cv_make_support_nested_variables+:} false; then :
    7846   $as_echo_n "(cached) " >&6
    7847 else
    7848   if $as_echo 'TRUE=$(BAR$(V))
    7849 BAR0=false
    7850 BAR1=true
    7851 V=1
    7852 am__doit:
    7853         @$(TRUE)
    7854 .PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
    7855   am_cv_make_support_nested_variables=yes
    7856 else
    7857   am_cv_make_support_nested_variables=no
    7858 fi
    7859 fi
    7860 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
    7861 $as_echo "$am_cv_make_support_nested_variables" >&6; }
    7862 if test $am_cv_make_support_nested_variables = yes; then
    7863     AM_V='$(V)'
    7864   AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
    7865 else
    7866   AM_V=$AM_DEFAULT_VERBOSITY
    7867   AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
    7868 fi
    7869 AM_BACKSLASH='\'
    7870 
    7871 
    7872 # disable automatic rebuild of configure/Makefile
    7873 
    7874 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to enable maintainer-specific portions of Makefiles" >&5
    7875 $as_echo_n "checking whether to enable maintainer-specific portions of Makefiles... " >&6; }
    7876     # Check whether --enable-maintainer-mode was given.
    7877 if test "${enable_maintainer_mode+set}" = set; then :
    7878   enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval
    7879 else
    7880   USE_MAINTAINER_MODE=no
    7881 fi
    7882 
    7883   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5
    7884 $as_echo "$USE_MAINTAINER_MODE" >&6; }
    7885    if test $USE_MAINTAINER_MODE = yes; then
    7886   MAINTAINER_MODE_TRUE=
    7887   MAINTAINER_MODE_FALSE='#'
    7888 else
    7889   MAINTAINER_MODE_TRUE='#'
    7890   MAINTAINER_MODE_FALSE=
    7891 fi
    7892 
    7893   MAINT=$MAINTAINER_MODE_TRUE
    7894 
    78957721
    78967722
     
    1220012026
    1220112027
    12202 #############################################################################
    12203 #                         Standard build tool stuff                         #
    12204 #############################################################################
    12205 
    12206 # Get the name of the C compiler
    12207 ac_ext=c
    12208 ac_cpp='$CPP $CPPFLAGS'
    12209 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    12210 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    12211 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    12212 if test -n "$ac_tool_prefix"; then
    12213   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
    12214 set dummy ${ac_tool_prefix}gcc; ac_word=$2
    12215 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    12216 $as_echo_n "checking for $ac_word... " >&6; }
    12217 if ${ac_cv_prog_CC+:} false; then :
    12218   $as_echo_n "(cached) " >&6
    12219 else
    12220   if test -n "$CC"; then
    12221   ac_cv_prog_CC="$CC" # Let the user override the test.
    12222 else
    12223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    12224 for as_dir in $PATH
    12225 do
    12226   IFS=$as_save_IFS
    12227   test -z "$as_dir" && as_dir=.
    12228     for ac_exec_ext in '' $ac_executable_extensions; do
    12229   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    12230     ac_cv_prog_CC="${ac_tool_prefix}gcc"
    12231     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    12232     break 2
    12233   fi
    12234 done
    12235   done
    12236 IFS=$as_save_IFS
    12237 
    12238 fi
    12239 fi
    12240 CC=$ac_cv_prog_CC
    12241 if test -n "$CC"; then
    12242   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    12243 $as_echo "$CC" >&6; }
    12244 else
    12245   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    12246 $as_echo "no" >&6; }
    12247 fi
    12248 
    12249 
    12250 fi
    12251 if test -z "$ac_cv_prog_CC"; then
    12252   ac_ct_CC=$CC
    12253   # Extract the first word of "gcc", so it can be a program name with args.
    12254 set dummy gcc; ac_word=$2
    12255 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    12256 $as_echo_n "checking for $ac_word... " >&6; }
    12257 if ${ac_cv_prog_ac_ct_CC+:} false; then :
    12258   $as_echo_n "(cached) " >&6
    12259 else
    12260   if test -n "$ac_ct_CC"; then
    12261   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
    12262 else
    12263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    12264 for as_dir in $PATH
    12265 do
    12266   IFS=$as_save_IFS
    12267   test -z "$as_dir" && as_dir=.
    12268     for ac_exec_ext in '' $ac_executable_extensions; do
    12269   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    12270     ac_cv_prog_ac_ct_CC="gcc"
    12271     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    12272     break 2
    12273   fi
    12274 done
    12275   done
    12276 IFS=$as_save_IFS
    12277 
    12278 fi
    12279 fi
    12280 ac_ct_CC=$ac_cv_prog_ac_ct_CC
    12281 if test -n "$ac_ct_CC"; then
    12282   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
    12283 $as_echo "$ac_ct_CC" >&6; }
    12284 else
    12285   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    12286 $as_echo "no" >&6; }
    12287 fi
    12288 
    12289   if test "x$ac_ct_CC" = x; then
    12290     CC=""
    12291   else
    12292     case $cross_compiling:$ac_tool_warned in
    12293 yes:)
    12294 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    12295 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    12296 ac_tool_warned=yes ;;
    12297 esac
    12298     CC=$ac_ct_CC
    12299   fi
    12300 else
    12301   CC="$ac_cv_prog_CC"
    12302 fi
    12303 
    12304 if test -z "$CC"; then
    12305           if test -n "$ac_tool_prefix"; then
    12306     # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
    12307 set dummy ${ac_tool_prefix}cc; ac_word=$2
    12308 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    12309 $as_echo_n "checking for $ac_word... " >&6; }
    12310 if ${ac_cv_prog_CC+:} false; then :
    12311   $as_echo_n "(cached) " >&6
    12312 else
    12313   if test -n "$CC"; then
    12314   ac_cv_prog_CC="$CC" # Let the user override the test.
    12315 else
    12316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    12317 for as_dir in $PATH
    12318 do
    12319   IFS=$as_save_IFS
    12320   test -z "$as_dir" && as_dir=.
    12321     for ac_exec_ext in '' $ac_executable_extensions; do
    12322   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    12323     ac_cv_prog_CC="${ac_tool_prefix}cc"
    12324     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    12325     break 2
    12326   fi
    12327 done
    12328   done
    12329 IFS=$as_save_IFS
    12330 
    12331 fi
    12332 fi
    12333 CC=$ac_cv_prog_CC
    12334 if test -n "$CC"; then
    12335   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    12336 $as_echo "$CC" >&6; }
    12337 else
    12338   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    12339 $as_echo "no" >&6; }
    12340 fi
    12341 
    12342 
    12343   fi
    12344 fi
    12345 if test -z "$CC"; then
    12346   # Extract the first word of "cc", so it can be a program name with args.
    12347 set dummy cc; ac_word=$2
    12348 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    12349 $as_echo_n "checking for $ac_word... " >&6; }
    12350 if ${ac_cv_prog_CC+:} false; then :
    12351   $as_echo_n "(cached) " >&6
    12352 else
    12353   if test -n "$CC"; then
    12354   ac_cv_prog_CC="$CC" # Let the user override the test.
    12355 else
    12356   ac_prog_rejected=no
    12357 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    12358 for as_dir in $PATH
    12359 do
    12360   IFS=$as_save_IFS
    12361   test -z "$as_dir" && as_dir=.
    12362     for ac_exec_ext in '' $ac_executable_extensions; do
    12363   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    12364     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
    12365        ac_prog_rejected=yes
    12366        continue
    12367      fi
    12368     ac_cv_prog_CC="cc"
    12369     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    12370     break 2
    12371   fi
    12372 done
    12373   done
    12374 IFS=$as_save_IFS
    12375 
    12376 if test $ac_prog_rejected = yes; then
    12377   # We found a bogon in the path, so make sure we never use it.
    12378   set dummy $ac_cv_prog_CC
    12379   shift
    12380   if test $# != 0; then
    12381     # We chose a different compiler from the bogus one.
    12382     # However, it has the same basename, so the bogon will be chosen
    12383     # first if we set CC to just the basename; use the full file name.
    12384     shift
    12385     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
    12386   fi
    12387 fi
    12388 fi
    12389 fi
    12390 CC=$ac_cv_prog_CC
    12391 if test -n "$CC"; then
    12392   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    12393 $as_echo "$CC" >&6; }
    12394 else
    12395   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    12396 $as_echo "no" >&6; }
    12397 fi
    12398 
    12399 
    12400 fi
    12401 if test -z "$CC"; then
    12402   if test -n "$ac_tool_prefix"; then
    12403   for ac_prog in cl.exe
    12404   do
    12405     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
    12406 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
    12407 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    12408 $as_echo_n "checking for $ac_word... " >&6; }
    12409 if ${ac_cv_prog_CC+:} false; then :
    12410   $as_echo_n "(cached) " >&6
    12411 else
    12412   if test -n "$CC"; then
    12413   ac_cv_prog_CC="$CC" # Let the user override the test.
    12414 else
    12415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    12416 for as_dir in $PATH
    12417 do
    12418   IFS=$as_save_IFS
    12419   test -z "$as_dir" && as_dir=.
    12420     for ac_exec_ext in '' $ac_executable_extensions; do
    12421   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    12422     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
    12423     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    12424     break 2
    12425   fi
    12426 done
    12427   done
    12428 IFS=$as_save_IFS
    12429 
    12430 fi
    12431 fi
    12432 CC=$ac_cv_prog_CC
    12433 if test -n "$CC"; then
    12434   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
    12435 $as_echo "$CC" >&6; }
    12436 else
    12437   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    12438 $as_echo "no" >&6; }
    12439 fi
    12440 
    12441 
    12442     test -n "$CC" && break
    12443   done
    12444 fi
    12445 if test -z "$CC"; then
    12446   ac_ct_CC=$CC
    12447   for ac_prog in cl.exe
    12448 do
    12449   # Extract the first word of "$ac_prog", so it can be a program name with args.
    12450 set dummy $ac_prog; ac_word=$2
    12451 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
    12452 $as_echo_n "checking for $ac_word... " >&6; }
    12453 if ${ac_cv_prog_ac_ct_CC+:} false; then :
    12454   $as_echo_n "(cached) " >&6
    12455 else
    12456   if test -n "$ac_ct_CC"; then
    12457   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
    12458 else
    12459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
    12460 for as_dir in $PATH
    12461 do
    12462   IFS=$as_save_IFS
    12463   test -z "$as_dir" && as_dir=.
    12464     for ac_exec_ext in '' $ac_executable_extensions; do
    12465   if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
    12466     ac_cv_prog_ac_ct_CC="$ac_prog"
    12467     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
    12468     break 2
    12469   fi
    12470 done
    12471   done
    12472 IFS=$as_save_IFS
    12473 
    12474 fi
    12475 fi
    12476 ac_ct_CC=$ac_cv_prog_ac_ct_CC
    12477 if test -n "$ac_ct_CC"; then
    12478   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
    12479 $as_echo "$ac_ct_CC" >&6; }
    12480 else
    12481   { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
    12482 $as_echo "no" >&6; }
    12483 fi
    12484 
    12485 
    12486   test -n "$ac_ct_CC" && break
    12487 done
    12488 
    12489   if test "x$ac_ct_CC" = x; then
    12490     CC=""
    12491   else
    12492     case $cross_compiling:$ac_tool_warned in
    12493 yes:)
    12494 { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
    12495 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
    12496 ac_tool_warned=yes ;;
    12497 esac
    12498     CC=$ac_ct_CC
    12499   fi
    12500 fi
    12501 
    12502 fi
    12503 
    12504 
    12505 test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
    12506 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
    12507 as_fn_error $? "no acceptable C compiler found in \$PATH
    12508 See \`config.log' for more details" "$LINENO" 5; }
    12509 
    12510 # Provide some information about the compiler.
    12511 $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
    12512 set X $ac_compile
    12513 ac_compiler=$2
    12514 for ac_option in --version -v -V -qversion; do
    12515   { { ac_try="$ac_compiler $ac_option >&5"
    12516 case "(($ac_try" in
    12517   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
    12518   *) ac_try_echo=$ac_try;;
    12519 esac
    12520 eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
    12521 $as_echo "$ac_try_echo"; } >&5
    12522   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
    12523   ac_status=$?
    12524   if test -s conftest.err; then
    12525     sed '10a\
    12526 ... rest of stderr output deleted ...
    12527          10q' conftest.err >conftest.er1
    12528     cat conftest.er1 >&5
    12529   fi
    12530   rm -f conftest.er1 conftest.err
    12531   $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
    12532   test $ac_status = 0; }
    12533 done
    12534 
    12535 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
    12536 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
    12537 if ${ac_cv_c_compiler_gnu+:} false; then :
    12538   $as_echo_n "(cached) " >&6
    12539 else
    12540   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    12541 /* end confdefs.h.  */
    12542 
    12543 int
    12544 main ()
    12545 {
    12546 #ifndef __GNUC__
    12547        choke me
    12548 #endif
    12549 
    12550   ;
    12551   return 0;
    12552 }
    12553 _ACEOF
    12554 if ac_fn_c_try_compile "$LINENO"; then :
    12555   ac_compiler_gnu=yes
    12556 else
    12557   ac_compiler_gnu=no
    12558 fi
    12559 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    12560 ac_cv_c_compiler_gnu=$ac_compiler_gnu
    12561 
    12562 fi
    12563 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
    12564 $as_echo "$ac_cv_c_compiler_gnu" >&6; }
    12565 if test $ac_compiler_gnu = yes; then
    12566   GCC=yes
    12567 else
    12568   GCC=
    12569 fi
    12570 ac_test_CFLAGS=${CFLAGS+set}
    12571 ac_save_CFLAGS=$CFLAGS
    12572 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
    12573 $as_echo_n "checking whether $CC accepts -g... " >&6; }
    12574 if ${ac_cv_prog_cc_g+:} false; then :
    12575   $as_echo_n "(cached) " >&6
    12576 else
    12577   ac_save_c_werror_flag=$ac_c_werror_flag
    12578    ac_c_werror_flag=yes
    12579    ac_cv_prog_cc_g=no
    12580    CFLAGS="-g"
    12581    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    12582 /* end confdefs.h.  */
    12583 
    12584 int
    12585 main ()
    12586 {
    12587 
    12588   ;
    12589   return 0;
    12590 }
    12591 _ACEOF
    12592 if ac_fn_c_try_compile "$LINENO"; then :
    12593   ac_cv_prog_cc_g=yes
    12594 else
    12595   CFLAGS=""
    12596       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    12597 /* end confdefs.h.  */
    12598 
    12599 int
    12600 main ()
    12601 {
    12602 
    12603   ;
    12604   return 0;
    12605 }
    12606 _ACEOF
    12607 if ac_fn_c_try_compile "$LINENO"; then :
    12608 
    12609 else
    12610   ac_c_werror_flag=$ac_save_c_werror_flag
    12611          CFLAGS="-g"
    12612          cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    12613 /* end confdefs.h.  */
    12614 
    12615 int
    12616 main ()
    12617 {
    12618 
    12619   ;
    12620   return 0;
    12621 }
    12622 _ACEOF
    12623 if ac_fn_c_try_compile "$LINENO"; then :
    12624   ac_cv_prog_cc_g=yes
    12625 fi
    12626 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    12627 fi
    12628 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    12629 fi
    12630 rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
    12631    ac_c_werror_flag=$ac_save_c_werror_flag
    12632 fi
    12633 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
    12634 $as_echo "$ac_cv_prog_cc_g" >&6; }
    12635 if test "$ac_test_CFLAGS" = set; then
    12636   CFLAGS=$ac_save_CFLAGS
    12637 elif test $ac_cv_prog_cc_g = yes; then
    12638   if test "$GCC" = yes; then
    12639     CFLAGS="-g -O2"
    12640   else
    12641     CFLAGS="-g"
    12642   fi
    12643 else
    12644   if test "$GCC" = yes; then
    12645     CFLAGS="-O2"
    12646   else
    12647     CFLAGS=
    12648   fi
    12649 fi
    12650 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
    12651 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
    12652 if ${ac_cv_prog_cc_c89+:} false; then :
    12653   $as_echo_n "(cached) " >&6
    12654 else
    12655   ac_cv_prog_cc_c89=no
    12656 ac_save_CC=$CC
    12657 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    12658 /* end confdefs.h.  */
    12659 #include <stdarg.h>
    12660 #include <stdio.h>
    12661 struct stat;
    12662 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
    12663 struct buf { int x; };
    12664 FILE * (*rcsopen) (struct buf *, struct stat *, int);
    12665 static char *e (p, i)
    12666      char **p;
    12667      int i;
    12668 {
    12669   return p[i];
    12670 }
    12671 static char *f (char * (*g) (char **, int), char **p, ...)
    12672 {
    12673   char *s;
    12674   va_list v;
    12675   va_start (v,p);
    12676   s = g (p, va_arg (v,int));
    12677   va_end (v);
    12678   return s;
    12679 }
    12680 
    12681 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
    12682    function prototypes and stuff, but not '\xHH' hex character constants.
    12683    These don't provoke an error unfortunately, instead are silently treated
    12684    as 'x'.  The following induces an error, until -std is added to get
    12685    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
    12686    array size at least.  It's necessary to write '\x00'==0 to get something
    12687    that's true only with -std.  */
    12688 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
    12689 
    12690 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
    12691    inside strings and character constants.  */
    12692 #define FOO(x) 'x'
    12693 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
    12694 
    12695 int test (int i, double x);
    12696 struct s1 {int (*f) (int a);};
    12697 struct s2 {int (*f) (double a);};
    12698 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
    12699 int argc;
    12700 char **argv;
    12701 int
    12702 main ()
    12703 {
    12704 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
    12705   ;
    12706   return 0;
    12707 }
    12708 _ACEOF
    12709 for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
    12710         -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
    12711 do
    12712   CC="$ac_save_CC $ac_arg"
    12713   if ac_fn_c_try_compile "$LINENO"; then :
    12714   ac_cv_prog_cc_c89=$ac_arg
    12715 fi
    12716 rm -f core conftest.err conftest.$ac_objext
    12717   test "x$ac_cv_prog_cc_c89" != "xno" && break
    12718 done
    12719 rm -f conftest.$ac_ext
    12720 CC=$ac_save_CC
    12721 
    12722 fi
    12723 # AC_CACHE_VAL
    12724 case "x$ac_cv_prog_cc_c89" in
    12725   x)
    12726     { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
    12727 $as_echo "none needed" >&6; } ;;
    12728   xno)
    12729     { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
    12730 $as_echo "unsupported" >&6; } ;;
    12731   *)
    12732     CC="$CC $ac_cv_prog_cc_c89"
    12733     { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
    12734 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
    12735 esac
    12736 if test "x$ac_cv_prog_cc_c89" != xno; then :
    12737 
    12738 fi
    12739 
    12740 ac_ext=c
    12741 ac_cpp='$CPP $CPPFLAGS'
    12742 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    12743 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    12744 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    12745 
    12746 ac_ext=c
    12747 ac_cpp='$CPP $CPPFLAGS'
    12748 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    12749 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    12750 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    12751 { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
    12752 $as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
    12753 if ${am_cv_prog_cc_c_o+:} false; then :
    12754   $as_echo_n "(cached) " >&6
    12755 else
    12756   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
    12757 /* end confdefs.h.  */
    12758 
    12759 int
    12760 main ()
    12761 {
    12762 
    12763   ;
    12764   return 0;
    12765 }
    12766 _ACEOF
    12767   # Make sure it works both with $CC and with simple cc.
    12768   # Following AC_PROG_CC_C_O, we do the test twice because some
    12769   # compilers refuse to overwrite an existing .o file with -o,
    12770   # though they will create one.
    12771   am_cv_prog_cc_c_o=yes
    12772   for am_i in 1 2; do
    12773     if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
    12774    ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
    12775    ac_status=$?
    12776    echo "$as_me:$LINENO: \$? = $ac_status" >&5
    12777    (exit $ac_status); } \
    12778          && test -f conftest2.$ac_objext; then
    12779       : OK
    12780     else
    12781       am_cv_prog_cc_c_o=no
    12782       break
    12783     fi
    12784   done
    12785   rm -f core conftest*
    12786   unset am_i
    12787 fi
    12788 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
    12789 $as_echo "$am_cv_prog_cc_c_o" >&6; }
    12790 if test "$am_cv_prog_cc_c_o" != yes; then
    12791    # Losing compiler, so override with the script.
    12792    # FIXME: It is wrong to rewrite CC.
    12793    # But if we don't then we get into trouble of one sort or another.
    12794    # A longer-term fix would be to have automake use am__CC in this case,
    12795    # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
    12796    CC="$am_aux_dir/compile $CC"
    12797 fi
    12798 ac_ext=c
    12799 ac_cpp='$CPP $CPPFLAGS'
    12800 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
    12801 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
    12802 ac_compiler_gnu=$ac_cv_c_compiler_gnu
    12803 
    12804 
    12805 depcc="$CC"   am_compiler_list=
    12806 
    12807 { $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
    12808 $as_echo_n "checking dependency style of $depcc... " >&6; }
    12809 if ${am_cv_CC_dependencies_compiler_type+:} false; then :
    12810   $as_echo_n "(cached) " >&6
    12811 else
    12812   if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
    12813   # We make a subdir and do the tests there.  Otherwise we can end up
    12814   # making bogus files that we don't know about and never remove.  For
    12815   # instance it was reported that on HP-UX the gcc test will end up
    12816   # making a dummy file named 'D' -- because '-MD' means "put the output
    12817   # in D".
    12818   rm -rf conftest.dir
    12819   mkdir conftest.dir
    12820   # Copy depcomp to subdir because otherwise we won't find it if we're
    12821   # using a relative directory.
    12822   cp "$am_depcomp" conftest.dir
    12823   cd conftest.dir
    12824   # We will build objects and dependencies in a subdirectory because
    12825   # it helps to detect inapplicable dependency modes.  For instance
    12826   # both Tru64's cc and ICC support -MD to output dependencies as a
    12827   # side effect of compilation, but ICC will put the dependencies in
    12828   # the current directory while Tru64 will put them in the object
    12829   # directory.
    12830   mkdir sub
    12831 
    12832   am_cv_CC_dependencies_compiler_type=none
    12833   if test "$am_compiler_list" = ""; then
    12834      am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
    12835   fi
    12836   am__universal=false
    12837   case " $depcc " in #(
    12838      *\ -arch\ *\ -arch\ *) am__universal=true ;;
    12839      esac
    12840 
    12841   for depmode in $am_compiler_list; do
    12842     # Setup a source with many dependencies, because some compilers
    12843     # like to wrap large dependency lists on column 80 (with \), and
    12844     # we should not choose a depcomp mode which is confused by this.
    12845     #
    12846     # We need to recreate these files for each test, as the compiler may
    12847     # overwrite some of them when testing with obscure command lines.
    12848     # This happens at least with the AIX C compiler.
    12849     : > sub/conftest.c
    12850     for i in 1 2 3 4 5 6; do
    12851       echo '#include "conftst'$i'.h"' >> sub/conftest.c
    12852       # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
    12853       # Solaris 10 /bin/sh.
    12854       echo '/* dummy */' > sub/conftst$i.h
    12855     done
    12856     echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
    12857 
    12858     # We check with '-c' and '-o' for the sake of the "dashmstdout"
    12859     # mode.  It turns out that the SunPro C++ compiler does not properly
    12860     # handle '-M -o', and we need to detect this.  Also, some Intel
    12861     # versions had trouble with output in subdirs.
    12862     am__obj=sub/conftest.${OBJEXT-o}
    12863     am__minus_obj="-o $am__obj"
    12864     case $depmode in
    12865     gcc)
    12866       # This depmode causes a compiler race in universal mode.
    12867       test "$am__universal" = false || continue
    12868       ;;
    12869     nosideeffect)
    12870       # After this tag, mechanisms are not by side-effect, so they'll
    12871       # only be used when explicitly requested.
    12872       if test "x$enable_dependency_tracking" = xyes; then
    12873         continue
    12874       else
    12875         break
    12876       fi
    12877       ;;
    12878     msvc7 | msvc7msys | msvisualcpp | msvcmsys)
    12879       # This compiler won't grok '-c -o', but also, the minuso test has
    12880       # not run yet.  These depmodes are late enough in the game, and
    12881       # so weak that their functioning should not be impacted.
    12882       am__obj=conftest.${OBJEXT-o}
    12883       am__minus_obj=
    12884       ;;
    12885     none) break ;;
    12886     esac
    12887     if depmode=$depmode \
    12888        source=sub/conftest.c object=$am__obj \
    12889        depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
    12890        $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
    12891          >/dev/null 2>conftest.err &&
    12892        grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
    12893        grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
    12894        grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
    12895        ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
    12896       # icc doesn't choke on unknown options, it will just issue warnings
    12897       # or remarks (even with -Werror).  So we grep stderr for any message
    12898       # that says an option was ignored or not supported.
    12899       # When given -MP, icc 7.0 and 7.1 complain thusly:
    12900       #   icc: Command line warning: ignoring option '-M'; no argument required
    12901       # The diagnosis changed in icc 8.0:
    12902       #   icc: Command line remark: option '-MP' not supported
    12903       if (grep 'ignoring option' conftest.err ||
    12904           grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
    12905         am_cv_CC_dependencies_compiler_type=$depmode
    12906         break
    12907       fi
    12908     fi
    12909   done
    12910 
    12911   cd ..
    12912   rm -rf conftest.dir
    12913 else
    12914   am_cv_CC_dependencies_compiler_type=none
    12915 fi
    12916 
    12917 fi
    12918 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
    12919 $as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
    12920 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
    12921 
    12922  if
    12923   test "x$enable_dependency_tracking" != xno \
    12924   && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
    12925   am__fastdepCC_TRUE=
    12926   am__fastdepCC_FALSE='#'
    12927 else
    12928   am__fastdepCC_TRUE='#'
    12929   am__fastdepCC_FALSE=
    12930 fi
    12931 
    12932 
    12933 
    1293412028###########################################################################
    1293512029#                            check GLPK version                           #
     
    1351412608if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
    1351512609  as_fn_error $? "conditional \"AMDEP\" was never defined.
    13516 Usually this means the macro was only invoked conditionally." "$LINENO" 5
    13517 fi
    13518 if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
    13519   as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
    1352012610Usually this means the macro was only invoked conditionally." "$LINENO" 5
    1352112611fi
  • ThirdParty/Glpk/branches/autotools-update/configure.ac

    r3624 r3675  
    2929
    3030# Get the name of the C compiler
    31 AC_PROG_CC
     31AC_COIN_PROG_CC
     32
     33# Initialize libtool
     34AC_COIN_PROG_LIBTOOL
    3235
    3336###########################################################################
Note: See TracChangeset for help on using the changeset viewer.