configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc extra_mpfr_configure_flags extra_mpc_gmp_configure_flags extra_mpc_mpfr_configure_flags stage1_ldflags stage1_libs poststage1_ldflags poststage1_libs ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir compare_exclusions LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-build-with-cxx build with C++ compiler instead of C compiler
 939   --disable-ppl-version-check    disable check for PPL version
 940   --disable-cloog-version-check  disable check for CLooG version
 941   --enable-stage1-languages[=all]   choose additional languages to build during
 942                           stage1.  Mostly useful for compiler development.
 943   --enable-objc-gc        enable use of Boehm's garbage collector with the
 944                           GNU Objective-C runtime
 945   --enable-bootstrap      enable bootstrapping [yes if native build]
 946   --enable-serial-[{host,target,build}-]configure
 947                           force sequential configuration of
 948                           sub-packages for the host, target or build
 949                           machine, or all sub-packages
 950   --enable-maintainer-mode enable make rules and dependencies not useful
 951                           (and sometimes confusing) to the casual installer
 952   --enable-stage1-checking[=all]   choose additional checking for stage1
 953                           of the compiler
 954   --enable-werror         enable -Werror in bootstrap stage2 and later
 955
 956 Optional Packages:
 957   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 958   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 959   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 960   --with-mpc=PATH        specify prefix directory for installed MPC package.
 961                           Equivalent to --with-mpc-include=PATH/include
 962                           plus --with-mpc-lib=PATH/lib
 963   --with-mpc-include=PATH
 964                           specify directory for installed MPC include files
 965   --with-mpc-lib=PATH    specify directory for the installed MPC library
 966   --with-mpfr-dir=PATH    this option has been REMOVED
 967   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 968                           Equivalent to --with-mpfr-include=PATH/include
 969                           plus --with-mpfr-lib=PATH/lib
 970   --with-mpfr-include=PATH
 971                           specify directory for installed MPFR include files
 972   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 973   --with-gmp-dir=PATH     this option has been REMOVED
 974   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 975                           Equivalent to --with-gmp-include=PATH/include
 976                           plus --with-gmp-lib=PATH/lib
 977   --with-gmp-include=PATH specify directory for installed GMP include files
 978   --with-gmp-lib=PATH     specify directory for the installed GMP library
 979   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 980                           when linking with PPL
 981   --with-stage1-ldflags=FLAGS Linker flags for stage1
 982   -with-stage1-libs=LIBS      Libraries for stage1
 983   --with-boot-ldflags=FLAGS Linker flags for stage2 and later
 984   --with-boot-libs=LIBS     Libraries for stage2 and later
 985   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 986                           Equivalent to --with-ppl-include=PATH/include
 987                           plus --with-ppl-lib=PATH/lib
 988   --with-ppl-include=PATH Specify directory for installed PPL include files
 989   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 990   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 991                           Equivalent to --with-cloog-include=PATH/include
 992                           plus --with-cloog-lib=PATH/lib
 993   --with-cloog-include=PATH Specify directory for installed CLooG include files
 994   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 995   --with-build-sysroot=SYSROOT
 996                           use sysroot as the system root during the build
 997   --with-debug-prefix-map='A=B C=D ...'
 998                              map A to B, C to D ... in debug information
 999   --with-build-time-tools=PATH
1000                           use given path to find target tools during the build
1001   --with-datarootdir      use datarootdir as the data root directory.
1002   --with-docdir           install documentation in this directory.
1003   --with-pdfdir           install pdf in this directory.
1004   --with-htmldir          install html in this directory.
1005
1006 Some influential environment variables:
1007   CC          C compiler command
1008   CFLAGS      C compiler flags
1009   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1010               nonstandard directory <lib dir>
1011   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1012               headers in a nonstandard directory <include dir>
1013   CXX         C++ compiler command
1014   CXXFLAGS    C++ compiler flags
1015   AR          AR for the host
1016   AS          AS for the host
1017   DLLTOOL     DLLTOOL for the host
1018   LD          LD for the host
1019   LIPO        LIPO for the host
1020   NM          NM for the host
1021   RANLIB      RANLIB for the host
1022   STRIP       STRIP for the host
1023   WINDRES     WINDRES for the host
1024   WINDMC      WINDMC for the host
1025   OBJCOPY     OBJCOPY for the host
1026   OBJDUMP     OBJDUMP for the host
1027   CC_FOR_TARGET
1028               CC for the target
1029   CXX_FOR_TARGET
1030               CXX for the target
1031   GCC_FOR_TARGET
1032               GCC for the target
1033   GCJ_FOR_TARGET
1034               GCJ for the target
1035   GFORTRAN_FOR_TARGET
1036               GFORTRAN for the target
1037   AR_FOR_TARGET
1038               AR for the target
1039   AS_FOR_TARGET
1040               AS for the target
1041   DLLTOOL_FOR_TARGET
1042               DLLTOOL for the target
1043   LD_FOR_TARGET
1044               LD for the target
1045   LIPO_FOR_TARGET
1046               LIPO for the target
1047   NM_FOR_TARGET
1048               NM for the target
1049   OBJDUMP_FOR_TARGET
1050               OBJDUMP for the target
1051   RANLIB_FOR_TARGET
1052               RANLIB for the target
1053   STRIP_FOR_TARGET
1054               STRIP for the target
1055   WINDRES_FOR_TARGET
1056               WINDRES for the target
1057   WINDMC_FOR_TARGET
1058               WINDMC for the target
1059
1060 Use these variables to override the choices made by `configure' or to help
1061 it to find libraries and programs with nonstandard names/locations.
1062
1063 _ACEOF
1064 fi
1065
1066 if test "$ac_init_help" = "recursive"; then
1067   # If there are subdirs, report their specific --help.
1068   ac_popdir=`pwd`
1069   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1070     test -d $ac_dir || continue
1071     ac_builddir=.
1072
1073 if test "$ac_dir" != .; then
1074   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1075   # A "../" for each directory in $ac_dir_suffix.
1076   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1077 else
1078   ac_dir_suffix= ac_top_builddir=
1079 fi
1080
1081 case $srcdir in
1082   .)  # No --srcdir option.  We are building in place.
1083     ac_srcdir=.
1084     if test -z "$ac_top_builddir"; then
1085        ac_top_srcdir=.
1086     else
1087        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1088     fi ;;
1089   [\\/]* | ?:[\\/]* )  # Absolute path.
1090     ac_srcdir=$srcdir$ac_dir_suffix;
1091     ac_top_srcdir=$srcdir ;;
1092   *) # Relative path.
1093     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1094     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1095 esac
1096
1097 # Do not use `cd foo && pwd` to compute absolute paths, because
1098 # the directories may not exist.
1099 case `pwd` in
1100 .) ac_abs_builddir="$ac_dir";;
1101 *)
1102   case "$ac_dir" in
1103   .) ac_abs_builddir=`pwd`;;
1104   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1105   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1106   esac;;
1107 esac
1108 case $ac_abs_builddir in
1109 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1110 *)
1111   case ${ac_top_builddir}. in
1112   .) ac_abs_top_builddir=$ac_abs_builddir;;
1113   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1114   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1115   esac;;
1116 esac
1117 case $ac_abs_builddir in
1118 .) ac_abs_srcdir=$ac_srcdir;;
1119 *)
1120   case $ac_srcdir in
1121   .) ac_abs_srcdir=$ac_abs_builddir;;
1122   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1123   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1124   esac;;
1125 esac
1126 case $ac_abs_builddir in
1127 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1128 *)
1129   case $ac_top_srcdir in
1130   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1131   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1132   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1133   esac;;
1134 esac
1135
1136     cd $ac_dir
1137     # Check for guested configure; otherwise get Cygnus style configure.
1138     if test -f $ac_srcdir/configure.gnu; then
1139       echo
1140       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1141     elif test -f $ac_srcdir/configure; then
1142       echo
1143       $SHELL $ac_srcdir/configure  --help=recursive
1144     elif test -f $ac_srcdir/configure.ac ||
1145            test -f $ac_srcdir/configure.in; then
1146       echo
1147       $ac_configure --help
1148     else
1149       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1150     fi
1151     cd $ac_popdir
1152   done
1153 fi
1154
1155 test -n "$ac_init_help" && exit 0
1156 if $ac_init_version; then
1157   cat <<\_ACEOF
1158
1159 Copyright (C) 2003 Free Software Foundation, Inc.
1160 This configure script is free software; the Free Software Foundation
1161 gives unlimited permission to copy, distribute and modify it.
1162 _ACEOF
1163   exit 0
1164 fi
1165 exec 5>config.log
1166 cat >&5 <<_ACEOF
1167 This file contains any messages produced by compilers while
1168 running configure, to aid debugging if configure makes a mistake.
1169
1170 It was created by $as_me, which was
1171 generated by GNU Autoconf 2.59.  Invocation command line was
1172
1173   $ $0 $@
1174
1175 _ACEOF
1176 {
1177 cat <<_ASUNAME
1178 ## --------- ##
1179 ## Platform. ##
1180 ## --------- ##
1181
1182 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1183 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1184 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1185 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1186 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1187
1188 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1189 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1190
1191 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1192 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1193 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1194 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1195 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1196 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1197 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1198
1199 _ASUNAME
1200
1201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1202 for as_dir in $PATH
1203 do
1204   IFS=$as_save_IFS
1205   test -z "$as_dir" && as_dir=.
1206   echo "PATH: $as_dir"
1207 done
1208
1209 } >&5
1210
1211 cat >&5 <<_ACEOF
1212
1213
1214 ## ----------- ##
1215 ## Core tests. ##
1216 ## ----------- ##
1217
1218 _ACEOF
1219
1220
1221 # Keep a trace of the command line.
1222 # Strip out --no-create and --no-recursion so they do not pile up.
1223 # Strip out --silent because we don't want to record it for future runs.
1224 # Also quote any args containing shell meta-characters.
1225 # Make two passes to allow for proper duplicate-argument suppression.
1226 ac_configure_args=
1227 ac_configure_args0=
1228 ac_configure_args1=
1229 ac_sep=
1230 ac_must_keep_next=false
1231 for ac_pass in 1 2
1232 do
1233   for ac_arg
1234   do
1235     case $ac_arg in
1236     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1237     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1238     | -silent | --silent | --silen | --sile | --sil)
1239       continue ;;
1240     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1241       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1242     esac
1243     case $ac_pass in
1244     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1245     2)
1246       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1247       if test $ac_must_keep_next = true; then
1248         ac_must_keep_next=false # Got value, back to normal.
1249       else
1250         case $ac_arg in
1251           *=* | --config-cache | -C | -disable-* | --disable-* \
1252           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1253           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1254           | -with-* | --with-* | -without-* | --without-* | --x)
1255             case "$ac_configure_args0 " in
1256               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1257             esac
1258             ;;
1259           -* ) ac_must_keep_next=true ;;
1260         esac
1261       fi
1262       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1263       # Get rid of the leading space.
1264       ac_sep=" "
1265       ;;
1266     esac
1267   done
1268 done
1269 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1270 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1271
1272 # When interrupted or exit'd, cleanup temporary files, and complete
1273 # config.log.  We remove comments because anyway the quotes in there
1274 # would cause problems or look ugly.
1275 # WARNING: Be sure not to use single quotes in there, as some shells,
1276 # such as our DU 5.0 friend, will then `close' the trap.
1277 trap 'exit_status=$?
1278   # Save into config.log some information that might help in debugging.
1279   {
1280     echo
1281
1282     cat <<\_ASBOX
1283 ## ---------------- ##
1284 ## Cache variables. ##
1285 ## ---------------- ##
1286 _ASBOX
1287     echo
1288     # The following way of writing the cache mishandles newlines in values,
1289 {
1290   (set) 2>&1 |
1291     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1292     *ac_space=\ *)
1293       sed -n \
1294         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1295           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1296       ;;
1297     *)
1298       sed -n \
1299         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1300       ;;
1301     esac;
1302 }
1303     echo
1304
1305     cat <<\_ASBOX
1306 ## ----------------- ##
1307 ## Output variables. ##
1308 ## ----------------- ##
1309 _ASBOX
1310     echo
1311     for ac_var in $ac_subst_vars
1312     do
1313       eval ac_val=$`echo $ac_var`
1314       echo "$ac_var='"'"'$ac_val'"'"'"
1315     done | sort
1316     echo
1317
1318     if test -n "$ac_subst_files"; then
1319       cat <<\_ASBOX
1320 ## ------------- ##
1321 ## Output files. ##
1322 ## ------------- ##
1323 _ASBOX
1324       echo
1325       for ac_var in $ac_subst_files
1326       do
1327         eval ac_val=$`echo $ac_var`
1328         echo "$ac_var='"'"'$ac_val'"'"'"
1329       done | sort
1330       echo
1331     fi
1332
1333     if test -s confdefs.h; then
1334       cat <<\_ASBOX
1335 ## ----------- ##
1336 ## confdefs.h. ##
1337 ## ----------- ##
1338 _ASBOX
1339       echo
1340       sed "/^$/d" confdefs.h | sort
1341       echo
1342     fi
1343     test "$ac_signal" != 0 &&
1344       echo "$as_me: caught signal $ac_signal"
1345     echo "$as_me: exit $exit_status"
1346   } >&5
1347   rm -f core *.core &&
1348   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1349     exit $exit_status
1350      ' 0
1351 for ac_signal in 1 2 13 15; do
1352   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1353 done
1354 ac_signal=0
1355
1356 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1357 rm -rf conftest* confdefs.h
1358 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1359 echo >confdefs.h
1360
1361 # Predefined preprocessor variables.
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_NAME "$PACKAGE_NAME"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_STRING "$PACKAGE_STRING"
1380 _ACEOF
1381
1382
1383 cat >>confdefs.h <<_ACEOF
1384 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1385 _ACEOF
1386
1387
1388 # Let the site file select an alternate cache file if it wants to.
1389 # Prefer explicitly selected file to automatically selected ones.
1390 if test -z "$CONFIG_SITE"; then
1391   if test "x$prefix" != xNONE; then
1392     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1393   else
1394     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1395   fi
1396 fi
1397 for ac_site_file in $CONFIG_SITE; do
1398   if test -r "$ac_site_file"; then
1399     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1400 echo "$as_me: loading site script $ac_site_file" >&6;}
1401     sed 's/^/| /' "$ac_site_file" >&5
1402     . "$ac_site_file"
1403   fi
1404 done
1405
1406 if test -r "$cache_file"; then
1407   # Some versions of bash will fail to source /dev/null (special
1408   # files actually), so we avoid doing that.
1409   if test -f "$cache_file"; then
1410     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1411 echo "$as_me: loading cache $cache_file" >&6;}
1412     case $cache_file in
1413       [\\/]* | ?:[\\/]* ) . $cache_file;;
1414       *)                      . ./$cache_file;;
1415     esac
1416   fi
1417 else
1418   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1419 echo "$as_me: creating cache $cache_file" >&6;}
1420   >$cache_file
1421 fi
1422
1423 # Check that the precious variables saved in the cache have kept the same
1424 # value.
1425 ac_cache_corrupted=false
1426 for ac_var in `(set) 2>&1 |
1427                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1428   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1429   eval ac_new_set=\$ac_env_${ac_var}_set
1430   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1431   eval ac_new_val="\$ac_env_${ac_var}_value"
1432   case $ac_old_set,$ac_new_set in
1433     set,)
1434       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1435 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1436       ac_cache_corrupted=: ;;
1437     ,set)
1438       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1439 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1440       ac_cache_corrupted=: ;;
1441     ,);;
1442     *)
1443       if test "x$ac_old_val" != "x$ac_new_val"; then
1444         # differences in whitespace do not lead to failure.
1445         ac_old_val_w=`echo x $ac_old_val`
1446         ac_new_val_w=`echo x $ac_new_val`
1447         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1448           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1449 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1450           ac_cache_corrupted=:
1451         else
1452           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1453 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1454           eval $ac_var=\$ac_old_val
1455         fi
1456         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1457 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1458         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1459 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1460       fi;;
1461   esac
1462   # Pass precious variables to config.status.
1463   if test "$ac_new_set" = set; then
1464     case $ac_new_val in
1465     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1466       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1467     *) ac_arg=$ac_var=$ac_new_val ;;
1468     esac
1469     case " $ac_configure_args " in
1470       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1471       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1472     esac
1473   fi
1474 done
1475 if $ac_cache_corrupted; then
1476   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1477 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1478   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1479 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1480   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1481 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1482    { (exit 1); exit 1; }; }
1483 fi
1484
1485 ac_ext=c
1486 ac_cpp='$CPP $CPPFLAGS'
1487 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1488 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1489 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514 progname=$0
1515 # if PWD already has a value, it is probably wrong.
1516 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1517
1518 # Export original configure arguments for use by sub-configures.
1519 # Quote arguments with shell meta charatcers.
1520 TOPLEVEL_CONFIGURE_ARGUMENTS=
1521 set -- "$progname" "$@"
1522 for ac_arg
1523 do
1524   case "$ac_arg" in
1525   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1526     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1527     # if the argument is of the form -foo=baz, quote the baz part only
1528     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1529   *) ;;
1530   esac
1531   # Add the quoted argument to the list.
1532   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1533 done
1534 if test "$silent" = yes; then
1535   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1536 fi
1537 # Remove the initial space we just introduced and, as these will be
1538 # expanded by make, quote '$'.
1539 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1540
1541
1542 # Find the build, host, and target systems.
1543 ac_aux_dir=
1544 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1545   if test -f $ac_dir/install-sh; then
1546     ac_aux_dir=$ac_dir
1547     ac_install_sh="$ac_aux_dir/install-sh -c"
1548     break
1549   elif test -f $ac_dir/install.sh; then
1550     ac_aux_dir=$ac_dir
1551     ac_install_sh="$ac_aux_dir/install.sh -c"
1552     break
1553   elif test -f $ac_dir/shtool; then
1554     ac_aux_dir=$ac_dir
1555     ac_install_sh="$ac_aux_dir/shtool install -c"
1556     break
1557   fi
1558 done
1559 if test -z "$ac_aux_dir"; then
1560   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1561 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1562    { (exit 1); exit 1; }; }
1563 fi
1564 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1565 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1566 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1567
1568 # Make sure we can run config.sub.
1569 $ac_config_sub sun4 >/dev/null 2>&1 ||
1570   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1571 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1572    { (exit 1); exit 1; }; }
1573
1574 echo "$as_me:$LINENO: checking build system type" >&5
1575 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1576 if test "${ac_cv_build+set}" = set; then
1577   echo $ECHO_N "(cached) $ECHO_C" >&6
1578 else
1579   ac_cv_build_alias=$build_alias
1580 test -z "$ac_cv_build_alias" &&
1581   ac_cv_build_alias=`$ac_config_guess`
1582 test -z "$ac_cv_build_alias" &&
1583   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1584 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1585    { (exit 1); exit 1; }; }
1586 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1593 echo "${ECHO_T}$ac_cv_build" >&6
1594 build=$ac_cv_build
1595 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600  case ${build_alias} in
1601   "") build_noncanonical=${build} ;;
1602   *) build_noncanonical=${build_alias} ;;
1603 esac
1604
1605
1606
1607  case ${host_alias} in
1608   "") host_noncanonical=${build_noncanonical} ;;
1609   *) host_noncanonical=${host_alias} ;;
1610 esac
1611
1612
1613
1614  case ${target_alias} in
1615   "") target_noncanonical=${host_noncanonical} ;;
1616   *) target_noncanonical=${target_alias} ;;
1617 esac
1618
1619
1620
1621
1622 test "$host_noncanonical" = "$target_noncanonical" &&
1623   test "$program_prefix$program_suffix$program_transform_name" = \
1624     NONENONEs,x,x, &&
1625   program_transform_name=s,y,y,
1626
1627 echo "$as_me:$LINENO: checking host system type" >&5
1628 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1629 if test "${ac_cv_host+set}" = set; then
1630   echo $ECHO_N "(cached) $ECHO_C" >&6
1631 else
1632   ac_cv_host_alias=$host_alias
1633 test -z "$ac_cv_host_alias" &&
1634   ac_cv_host_alias=$ac_cv_build_alias
1635 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1636   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1637 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1638    { (exit 1); exit 1; }; }
1639
1640 fi
1641 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1642 echo "${ECHO_T}$ac_cv_host" >&6
1643 host=$ac_cv_host
1644 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1645 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1646 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1647
1648
1649 echo "$as_me:$LINENO: checking target system type" >&5
1650 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1651 if test "${ac_cv_target+set}" = set; then
1652   echo $ECHO_N "(cached) $ECHO_C" >&6
1653 else
1654   ac_cv_target_alias=$target_alias
1655 test "x$ac_cv_target_alias" = "x" &&
1656   ac_cv_target_alias=$ac_cv_host_alias
1657 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1658   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1659 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1660    { (exit 1); exit 1; }; }
1661
1662 fi
1663 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1664 echo "${ECHO_T}$ac_cv_target" >&6
1665 target=$ac_cv_target
1666 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1667 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1668 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1669
1670
1671 # The aliases save the names the user supplied, while $host etc.
1672 # will get canonicalized.
1673 test -n "$target_alias" &&
1674   test "$program_prefix$program_suffix$program_transform_name" = \
1675     NONENONEs,x,x, &&
1676   program_prefix=${target_alias}-
1677 test "$program_prefix" != NONE &&
1678   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1679 # Use a double $ so make ignores it.
1680 test "$program_suffix" != NONE &&
1681   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1682 # Double any \ or $.  echo might interpret backslashes.
1683 # By default was `s,x,x', remove it if useless.
1684 cat <<\_ACEOF >conftest.sed
1685 s/[\\$]/&&/g;s/;s,x,x,$//
1686 _ACEOF
1687 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1688 rm conftest.sed
1689
1690
1691
1692 # Get 'install' or 'install-sh' and its variants.
1693 # Find a good install program.  We prefer a C program (faster),
1694 # so one script is as good as another.  But avoid the broken or
1695 # incompatible versions:
1696 # SysV /etc/install, /usr/sbin/install
1697 # SunOS /usr/etc/install
1698 # IRIX /sbin/install
1699 # AIX /bin/install
1700 # AmigaOS /C/install, which installs bootblocks on floppy discs
1701 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1702 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1703 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1704 # OS/2's system install, which has a completely different semantic
1705 # ./install, which can be erroneously created by make from ./install.sh.
1706 # Reject install programs that cannot install multiple files.
1707 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1708 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1709 if test -z "$INSTALL"; then
1710 if test "${ac_cv_path_install+set}" = set; then
1711   echo $ECHO_N "(cached) $ECHO_C" >&6
1712 else
1713   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1714 for as_dir in $PATH
1715 do
1716   IFS=$as_save_IFS
1717   test -z "$as_dir" && as_dir=.
1718   # Account for people who put trailing slashes in PATH elements.
1719 case $as_dir/ in
1720   ./ | .// | /cC/* | \
1721   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1722   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1723   /usr/ucb/* ) ;;
1724   *)
1725     # OSF1 and SCO ODT 3.0 have their own names for install.
1726     # Don't use installbsd from OSF since it installs stuff as root
1727     # by default.
1728     for ac_prog in ginstall scoinst install; do
1729       for ac_exec_ext in '' $ac_executable_extensions; do
1730         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1731           if test $ac_prog = install &&
1732             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1733             # AIX install.  It has an incompatible calling convention.
1734             :
1735           elif test $ac_prog = install &&
1736             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1737             # program-specific install script used by HP pwplus--don't use.
1738             :
1739           else
1740             rm -rf conftest.one conftest.two conftest.dir
1741             echo one > conftest.one
1742             echo two > conftest.two
1743             mkdir conftest.dir
1744             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1745               test -s conftest.one && test -s conftest.two &&
1746               test -s conftest.dir/conftest.one &&
1747               test -s conftest.dir/conftest.two
1748             then
1749               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1750               break 3
1751             fi
1752           fi
1753         fi
1754       done
1755     done
1756     ;;
1757 esac
1758 done
1759
1760 rm -rf conftest.one conftest.two conftest.dir
1761
1762 fi
1763   if test "${ac_cv_path_install+set}" = set; then
1764     INSTALL=$ac_cv_path_install
1765   else
1766     # As a last resort, use the slow shell script.  Don't cache a
1767     # value for INSTALL within a source directory, because that will
1768     # break other packages using the cache if that directory is
1769     # removed, or if the value is a relative name.
1770     INSTALL=$ac_install_sh
1771   fi
1772 fi
1773 echo "$as_me:$LINENO: result: $INSTALL" >&5
1774 echo "${ECHO_T}$INSTALL" >&6
1775
1776 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1777 # It thinks the first close brace ends the variable substitution.
1778 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1779
1780 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1781
1782 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1783
1784 echo "$as_me:$LINENO: checking whether ln works" >&5
1785 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1786 if test "${acx_cv_prog_LN+set}" = set; then
1787   echo $ECHO_N "(cached) $ECHO_C" >&6
1788 else
1789   rm -f conftestdata_t
1790 echo >conftestdata_f
1791 if ln conftestdata_f conftestdata_t 2>/dev/null
1792 then
1793   acx_cv_prog_LN=ln
1794 else
1795   acx_cv_prog_LN=no
1796 fi
1797 rm -f conftestdata_f conftestdata_t
1798
1799 fi
1800 if test $acx_cv_prog_LN = no; then
1801   LN="cp"
1802   echo "$as_me:$LINENO: result: no, using $LN" >&5
1803 echo "${ECHO_T}no, using $LN" >&6
1804 else
1805   LN="$acx_cv_prog_LN"
1806   echo "$as_me:$LINENO: result: yes" >&5
1807 echo "${ECHO_T}yes" >&6
1808 fi
1809
1810 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1811 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1812 LN_S=$as_ln_s
1813 if test "$LN_S" = "ln -s"; then
1814   echo "$as_me:$LINENO: result: yes" >&5
1815 echo "${ECHO_T}yes" >&6
1816 else
1817   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1818 echo "${ECHO_T}no, using $LN_S" >&6
1819 fi
1820
1821
1822 ### we might need to use some other shell than /bin/sh for running subshells
1823 ### If we are on Windows, search for the shell.  This will permit people
1824 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1825 ### without also having to set CONFIG_SHELL.  This code will work when
1826 ### using bash, which sets OSTYPE.
1827 case "${OSTYPE}" in
1828 *win32*)
1829   if test x${CONFIG_SHELL} = x ; then
1830     if test ! -f /bin/sh ; then
1831       if test x${SHELL} != x && test -f ${SHELL} ; then
1832         CONFIG_SHELL=${SHELL}
1833         export CONFIG_SHELL
1834       else
1835         for prog in sh sh.exe bash bash.exe; do
1836           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1837           for dir in $PATH; do
1838             test -z "$dir" && dir=.
1839             if test -f $dir/$prog; then
1840               CONFIG_SHELL=$dir/$prog
1841               export CONFIG_SHELL
1842               break
1843             fi
1844           done
1845           IFS="$save_ifs"
1846           test -n "${CONFIG_SHELL}" && break
1847         done
1848       fi
1849     fi
1850   fi
1851   ;;
1852 esac
1853
1854 config_shell=${CONFIG_SHELL-/bin/sh}
1855
1856 moveifchange=${srcdir}/move-if-change
1857
1858 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1859
1860 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1861 # a relative path.
1862 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1863   INSTALL="${srcpwd}/install-sh -c"
1864 fi
1865
1866 # Set srcdir to "." if that's what it is.
1867 # This is important for multilib support.
1868 pwd=`${PWDCMD-pwd}`
1869 if test "${pwd}" = "${srcpwd}" ; then
1870   srcdir=.
1871 fi
1872
1873 topsrcdir=$srcpwd
1874
1875 extra_host_args=
1876
1877 ### To add a new directory to the tree, first choose whether it is a target
1878 ### or a host dependent tool.  Then put it into the appropriate list
1879 ### (library or tools, host or target), doing a dependency sort.
1880
1881 # Subdirs will be configured in the order listed in build_configdirs,
1882 # configdirs, or target_configdirs; see the serialization section below.
1883
1884 # Dependency sorting is only needed when *configuration* must be done in
1885 # a particular order.  In all cases a dependency should be specified in
1886 # the Makefile, whether or not it's implicitly specified here.
1887
1888 # Double entries in build_configdirs, configdirs, or target_configdirs may
1889 # cause circular dependencies and break everything horribly.
1890
1891 # these library is used by various programs built for the build
1892 # environment
1893 #
1894 build_libs="build-libiberty"
1895
1896 # these tools are built for the build environment
1897 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1898
1899 # these libraries are used by various programs built for the host environment
1900 #
1901 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1902
1903 # these tools are built for the host environment
1904 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1905 # know that we are building the simulator.
1906 # binutils, gas and ld appear in that order because it makes sense to run
1907 # "make check" in that particular order.
1908 # If --enable-gold is used, "gold" will replace "ld".
1909 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc cgen sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1910
1911 # libgcj represents the runtime libraries only used by gcj.
1912 libgcj="target-libffi \
1913         target-zlib \
1914         target-qthreads \
1915         target-libjava"
1916
1917 # these libraries are built for the target environment, and are built after
1918 # the host libraries and the host tools (which may be a cross compiler)
1919 #
1920 target_libraries="target-libgcc \
1921                 target-libiberty \
1922                 target-libgloss \
1923                 target-newlib \
1924                 target-libgomp \
1925                 target-libstdc++-v3 \
1926                 target-libmudflap \
1927                 target-libssp \
1928                 target-libgfortran \
1929                 target-boehm-gc \
1930                 ${libgcj} \
1931                 target-libobjc \
1932                 target-libada"
1933
1934 # these tools are built using the target libraries, and are intended to
1935 # run only in the target environment
1936 #
1937 # note: any program that *uses* libraries that are in the "target_libraries"
1938 # list belongs in this list.  those programs are also very likely
1939 # candidates for the "native_only" list which follows
1940 #
1941 target_tools="target-examples target-groff target-gperf target-rda"
1942
1943 ################################################################################
1944
1945 ## All tools belong in one of the four categories, and are assigned above
1946 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1947 ## is important because configure will choke if they ever get through.
1948 ## ${configdirs} is directories we build using the host tools.
1949 ## ${target_configdirs} is directories we build using the target tools.
1950 configdirs=`echo ${host_libs} ${host_tools}`
1951 target_configdirs=`echo ${target_libraries} ${target_tools}`
1952 build_configdirs=`echo ${build_libs} ${build_tools}`
1953
1954
1955
1956 ################################################################################
1957
1958 srcname="gnu development package"
1959
1960 # This gets set non-empty for some net releases of packages.
1961 appdirs=""
1962
1963 # Define is_cross_compiler to save on calls to 'test'.
1964 is_cross_compiler=
1965 if test x"${host}" = x"${target}" ; then
1966   is_cross_compiler=no
1967 else
1968   is_cross_compiler=yes
1969 fi
1970
1971 # Find the build and target subdir names.
1972
1973 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1974 # have matching libraries, they should use host libraries: Makefile.tpl
1975 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1976 # However, they still use the build modules, because the corresponding
1977 # host modules (e.g. bison) are only built for the host when bootstrap
1978 # finishes. So:
1979 # - build_subdir is where we find build modules, and never changes.
1980 # - build_libsubdir is where we find build libraries, and can be overridden.
1981
1982 # Prefix 'build-' so this never conflicts with target_subdir.
1983 build_subdir="build-${build_noncanonical}"
1984
1985 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1986 if test "${with_build_libsubdir+set}" = set; then
1987   withval="$with_build_libsubdir"
1988   build_libsubdir="$withval"
1989 else
1990   build_libsubdir="$build_subdir"
1991 fi;
1992 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1993 if ( test $srcdir = . && test -d gcc ) \
1994    || test -d $srcdir/../host-${host_noncanonical}; then
1995   host_subdir="host-${host_noncanonical}"
1996 else
1997   host_subdir=.
1998 fi
1999 # No prefix.
2000 target_subdir=${target_noncanonical}
2001
2002
2003 # Skipdirs are removed silently.
2004 skipdirs=
2005 # Noconfigdirs are removed loudly.
2006 noconfigdirs=""
2007
2008 use_gnu_ld=
2009 # Make sure we don't let GNU ld be added if we didn't want it.
2010 if test x$with_gnu_ld = xno ; then
2011   use_gnu_ld=no
2012   noconfigdirs="$noconfigdirs ld gold"
2013 fi
2014
2015 use_gnu_as=
2016 # Make sure we don't let GNU as be added if we didn't want it.
2017 if test x$with_gnu_as = xno ; then
2018   use_gnu_as=no
2019   noconfigdirs="$noconfigdirs gas"
2020 fi
2021
2022 # some tools are so dependent upon X11 that if we're not building with X,
2023 # it's not even worth trying to configure, much less build, that tool.
2024
2025 case ${with_x} in
2026   yes | "") ;; # the default value for this tree is that X11 is available
2027   no)
2028     skipdirs="${skipdirs} tk itcl libgui"
2029     # We won't be able to build gdbtk without X.
2030     enable_gdbtk=no
2031     ;;
2032   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2033 esac
2034
2035 # Some tools are only suitable for building in a "native" situation.
2036 # Remove these if host!=target.
2037 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2038
2039 # Similarly, some are only suitable for cross toolchains.
2040 # Remove these if host=target.
2041 cross_only="target-libgloss target-newlib target-opcodes"
2042
2043 case $is_cross_compiler in
2044   no) skipdirs="${skipdirs} ${cross_only}" ;;
2045   yes) skipdirs="${skipdirs} ${native_only}" ;;
2046 esac
2047
2048 # If both --with-headers and --with-libs are specified, default to
2049 # --without-newlib.
2050 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2051    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2052   if test x"${with_newlib}" = x ; then
2053     with_newlib=no
2054   fi
2055 fi
2056
2057 # Recognize --with-newlib/--without-newlib.
2058 case ${with_newlib} in
2059   no) skipdirs="${skipdirs} target-newlib" ;;
2060   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2061 esac
2062
2063 # Handle --enable-gold.
2064
2065 # Check whether --enable-gold or --disable-gold was given.
2066 if test "${enable_gold+set}" = set; then
2067   enableval="$enable_gold"
2068   ENABLE_GOLD=$enableval
2069 else
2070   ENABLE_GOLD=no
2071 fi;
2072 if test "${ENABLE_GOLD}" = "yes"; then
2073   # Check for ELF target.
2074   is_elf=no
2075   case "${target}" in
2076     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2077     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2078     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2* | *-*-nto*)
2079       case "${target}" in
2080         *-*-linux*aout* | *-*-linux*oldld*)
2081           ;;
2082         *)
2083           is_elf=yes
2084           ;;
2085       esac
2086   esac
2087
2088   if test "$is_elf" = "yes"; then
2089     # Check for target supported by gold.
2090     case "${target}" in
2091       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2092         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2093         ;;
2094     esac
2095   fi
2096 fi
2097
2098 # Configure extra directories which are host specific
2099
2100 case "${host}" in
2101   *-cygwin*)
2102     configdirs="$configdirs libtermcap" ;;
2103 esac
2104
2105 # A target can indicate whether a language isn't supported for some reason.
2106 # Only spaces may be used in this macro; not newlines or tabs.
2107 unsupported_languages=
2108
2109 # Remove more programs from consideration, based on the host or
2110 # target this usually means that a port of the program doesn't
2111 # exist yet.
2112
2113 case "${host}" in
2114   hppa*64*-*-*)
2115     noconfigdirs="$noconfigdirs byacc"
2116     ;;
2117   i[3456789]86-*-vsta)
2118     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2119     ;;
2120   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2121     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2122     ;;
2123   x86_64-*-mingw*)
2124     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2125     ;;
2126   i[3456789]86-*-mingw32*)
2127     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2128     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2129     ;;
2130   i[3456789]86-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2132     ;;
2133   *-*-cygwin*)
2134     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2135     ;;
2136   *-*-netbsd*)
2137     noconfigdirs="$noconfigdirs rcs"
2138     ;;
2139   ppc*-*-pe)
2140     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2141     ;;
2142   powerpc-*-beos*)
2143     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2144     ;;
2145 esac
2146
2147
2148 # Check whether --enable-libada or --disable-libada was given.
2149 if test "${enable_libada+set}" = set; then
2150   enableval="$enable_libada"
2151   ENABLE_LIBADA=$enableval
2152 else
2153   ENABLE_LIBADA=yes
2154 fi;
2155 if test "${ENABLE_LIBADA}" != "yes" ; then
2156   noconfigdirs="$noconfigdirs gnattools"
2157 fi
2158
2159 # Check whether --enable-libssp or --disable-libssp was given.
2160 if test "${enable_libssp+set}" = set; then
2161   enableval="$enable_libssp"
2162   ENABLE_LIBSSP=$enableval
2163 else
2164   ENABLE_LIBSSP=yes
2165 fi;
2166
2167 # Save it here so that, even in case of --enable-libgcj, if the Java
2168 # front-end isn't enabled, we still get libgcj disabled.
2169 libgcj_saved=$libgcj
2170 case $enable_libgcj in
2171 yes)
2172   # If we reset it here, it won't get added to noconfigdirs in the
2173   # target-specific build rules, so it will be forcibly enabled
2174   # (unless the Java language itself isn't enabled).
2175   libgcj=
2176   ;;
2177 no)
2178   # Make sure we get it printed in the list of not supported target libs.
2179   noconfigdirs="$noconfigdirs ${libgcj}"
2180   ;;
2181 esac
2182
2183
2184 # Disable libmudflap on some systems.
2185 if test x$enable_libmudflap = x ; then
2186     case "${target}" in
2187     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2188         # Enable libmudflap by default in GNU and friends.
2189         ;;
2190     *-*-freebsd*)
2191         # Enable libmudflap by default in FreeBSD.
2192         ;;
2193     *)
2194         # Disable it by default everywhere else.
2195         noconfigdirs="$noconfigdirs target-libmudflap"
2196         ;;
2197     esac
2198 fi
2199
2200 # Disable libgomp on non POSIX hosted systems.
2201 if test x$enable_libgomp = x ; then
2202     # Enable libgomp by default on hosted POSIX systems.
2203     case "${target}" in
2204     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2205         ;;
2206     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2207         ;;
2208     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2209         ;;
2210     *-*-darwin* | *-*-aix*)
2211         ;;
2212     *)
2213         noconfigdirs="$noconfigdirs target-libgomp"
2214         ;;
2215     esac
2216 fi
2217
2218 # Default libgloss CPU subdirectory.
2219 libgloss_dir="$target_cpu"
2220
2221 case "${target}" in
2222   *-*-chorusos)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   powerpc-*-darwin*)
2226     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2227     noconfigdirs="$noconfigdirs sim target-rda"
2228     ;;
2229   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2230     noconfigdirs="$noconfigdirs ld gas gprof"
2231     noconfigdirs="$noconfigdirs sim target-rda"
2232     ;;
2233   *-*-darwin*)
2234     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2235     noconfigdirs="$noconfigdirs sim target-rda"
2236     noconfigdirs="$noconfigdirs ${libgcj}"
2237     ;;
2238   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2239     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2240     ;;
2241   *-*-freebsd*)
2242     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2243     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2244         && test -f /usr/local/include/gmp.h; then
2245       with_gmp=/usr/local
2246     fi
2247
2248     # Skip some stuff that's unsupported on some FreeBSD configurations.
2249     case "${target}" in
2250       i*86-*-*) ;;
2251       alpha*-*-*) ;;
2252       *)
2253         noconfigdirs="$noconfigdirs ${libgcj}"
2254         ;;
2255     esac
2256     ;;
2257   *-*-kaos*)
2258     # Remove unsupported stuff on all kaOS configurations.
2259     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2260     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2261     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2262     noconfigdirs="$noconfigdirs target-libgloss"
2263     ;;
2264   *-*-netbsd*)
2265     # Skip some stuff on all NetBSD configurations.
2266     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2267
2268     # Skip some stuff that's unsupported on some NetBSD configurations.
2269     case "${target}" in
2270       i*86-*-netbsdelf*) ;;
2271       arm*-*-netbsdelf*) ;;
2272       *)
2273         noconfigdirs="$noconfigdirs ${libgcj}"
2274         ;;
2275     esac
2276     ;;
2277   *-*-netware*)
2278     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2279     ;;
2280   *-*-rtems*)
2281     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2282     ;;
2283     # The tpf target doesn't support gdb yet.
2284   *-*-tpf*)
2285     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2286     ;;
2287   *-*-uclinux*)
2288     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2289     ;;
2290   *-*-vxworks*)
2291     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2292     ;;
2293   alpha*-dec-osf*)
2294     # ld works, but does not support shared libraries.
2295     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2296     # gas doesn't generate exception information.
2297     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2298     ;;
2299   alpha*-*-*vms*)
2300     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2301     ;;
2302   alpha*-*-linux*)
2303     # newlib is not 64 bit ready
2304     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2305     ;;
2306   alpha*-*-*)
2307     # newlib is not 64 bit ready
2308     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2309     ;;
2310   am33_2.0-*-linux*)
2311     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2312     ;;
2313   sh-*-linux*)
2314     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2315     ;;
2316   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2317     noconfigdirs="$noconfigdirs ${libgcj}"
2318     noconfigdirs="$noconfigdirs target-examples"
2319     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2320     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2321     noconfigdirs="$noconfigdirs expect dejagnu"
2322     # the C++ libraries don't build on top of CE's C libraries
2323     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2324     noconfigdirs="$noconfigdirs target-newlib"
2325     case "${host}" in
2326       *-*-cygwin*) ;; # keep gdb and readline
2327       *) noconfigdirs="$noconfigdirs gdb readline"
2328          ;;
2329     esac
2330     libgloss_dir=wince
2331     ;;
2332   arc-*-*)
2333     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2334     ;;
2335   arm-semi-aof )
2336     ;;
2337   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2338     noconfigdirs="$noconfigdirs ${libgcj}"
2339     libgloss_dir=arm
2340     ;;
2341   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2342     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2343     libgloss_dir=arm
2344     ;;
2345   arm*-*-linux-gnueabi)
2346     noconfigdirs="$noconfigdirs target-qthreads"
2347     case ${with_newlib} in
2348       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2349     esac
2350     libgloss_dir=arm
2351     ;;
2352   arm*-*-symbianelf*)
2353     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2354     libgloss_dir=arm
2355     ;;
2356   arm-*-pe*)
2357     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2358     ;;
2359   thumb-*-coff)
2360     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2361     ;;
2362   thumb-*-elf)
2363     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2364     ;;
2365   thumb-*-pe)
2366     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2367     ;;
2368   arm-*-riscix*)
2369     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2370     ;;
2371   avr-*-*)
2372     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2373     ;;
2374   bfin-*-*)
2375     noconfigdirs="$noconfigdirs gdb"
2376     if test x${is_cross_compiler} != xno ; then
2377       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2378     fi
2379     ;;
2380   c4x-*-* | tic4x-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   c54x*-*-* | tic54x-*-*)
2384     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2385     ;;
2386   cr16-*-*)
2387     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2388     ;;
2389   cris-*-* | crisv32-*-*)
2390     unsupported_languages="$unsupported_languages java"
2391     case "${target}" in
2392       *-*-aout)
2393         unsupported_languages="$unsupported_languages fortran"
2394         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2395       *-*-elf)
2396         noconfigdirs="$noconfigdirs target-boehm-gc";;
2397       *-*-linux*)
2398         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2399       *)
2400         unsupported_languages="$unsupported_languages fortran"
2401         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2402     esac
2403     libgloss_dir=cris
2404     ;;
2405   crx-*-*)
2406     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2407     ;;
2408   d10v-*-*)
2409     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2410     ;;
2411   d30v-*-*)
2412     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2413     ;;
2414   ep9312-*-elf | ep9312-*-coff)
2415     libgloss_dir=arm
2416     ;;
2417   fr30-*-elf*)
2418     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2419     ;;
2420   frv-*-*)
2421     noconfigdirs="$noconfigdirs ${libgcj}"
2422     ;;
2423   moxie-*-*)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     noconfigdirs="$noconfigdirs gprof"
2426     ;;
2427   h8300*-*-*)
2428     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2429     ;;
2430   h8500-*-*)
2431     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2432     ;;
2433   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2434     ;;
2435   hppa*64*-*-linux* | parisc*64*-*-linux*)
2436     # In this case, it's because the hppa64-linux target is for
2437     # the kernel only at this point and has no libc, and thus no
2438     # headers, crt*.o, etc., all of which are needed by these.
2439     noconfigdirs="$noconfigdirs target-zlib"
2440     ;;
2441   parisc*-*-linux* | hppa*-*-linux*)
2442     ;;
2443   hppa*-*-*elf* | \
2444   hppa*-*-lites* | \
2445   hppa*-*-openbsd* | \
2446   hppa*64*-*-*)
2447     noconfigdirs="$noconfigdirs ${libgcj}"
2448     ;;
2449   hppa*-hp-hpux11*)
2450     noconfigdirs="$noconfigdirs ld shellutils"
2451     ;;
2452   hppa*-*-pro*)
2453     libgloss_dir=pa
2454     ;;
2455   hppa*-*-*)
2456     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2457     # build on HP-UX 10.20.
2458     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2459     ;;
2460   i960-*-*)
2461     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2462     ;;
2463   ia64*-*-elf*)
2464     # No gdb support yet.
2465     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2466     ;;
2467   ia64*-**-hpux*)
2468     # No gdb or ld support yet.
2469     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2470     ;;
2471   ia64*-*-*vms*)
2472     # No gdb or ld support yet.
2473     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2474     ;;
2475   i370-*-opened*)
2476     ;;
2477   i[3456789]86-*-coff | i[3456789]86-*-elf)
2478     noconfigdirs="$noconfigdirs ${libgcj}"
2479     libgloss_dir=i386
2480     ;;
2481   i[3456789]86-*-linux*)
2482     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2483     # not build java stuff by default.
2484     case "${target}" in
2485       *-*-*libc1*)
2486         noconfigdirs="$noconfigdirs ${libgcj}";;
2487     esac
2488
2489     # This section makes it possible to build newlib natively on linux.
2490     # If we are using a cross compiler then don't configure newlib.
2491     if test x${is_cross_compiler} != xno ; then
2492       noconfigdirs="$noconfigdirs target-newlib"
2493     fi
2494     noconfigdirs="$noconfigdirs target-libgloss"
2495     # If we are not using a cross compiler, do configure newlib.
2496     # Note however, that newlib will only be configured in this situation
2497     # if the --with-newlib option has been given, because otherwise
2498     # 'target-newlib' will appear in skipdirs.
2499     ;;
2500   i[3456789]86-*-mingw32*)
2501     target_configdirs="$target_configdirs target-winsup"
2502     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2503     ;;
2504   x86_64-*-mingw*)
2505     target_configdirs="$target_configdirs target-winsup"
2506     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2507     ;;
2508   *-*-cygwin*)
2509     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2510     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2511     # always build newlib if winsup directory is present.
2512     if test -d "$srcdir/winsup/cygwin"; then
2513       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2514     elif test -d "$srcdir/newlib"; then
2515       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2516     fi
2517     ;;
2518   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2519   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2520     ;;
2521   i[3456789]86-*-pe)
2522     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2523     ;;
2524   i[3456789]86-*-sco3.2v5*)
2525     # The linker does not yet know about weak symbols in COFF,
2526     # and is not configured to handle mixed ELF and COFF.
2527     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2528     ;;
2529   i[3456789]86-*-sco*)
2530     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2531     ;;
2532   i[3456789]86-*-solaris2*)
2533     noconfigdirs="$noconfigdirs target-libgloss"
2534     ;;
2535   i[3456789]86-*-sysv4*)
2536     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2537     ;;
2538   i[3456789]86-*-beos*)
2539     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2540     ;;
2541   i[3456789]86-*-rdos*)
2542     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2543     ;;
2544   m32r-*-*)
2545     noconfigdirs="$noconfigdirs ${libgcj}"
2546     ;;
2547   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2548     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2549     libgloss_dir=m68hc11
2550     ;;
2551   m68k-*-elf*)
2552     noconfigdirs="$noconfigdirs ${libgcj}"
2553     ;;
2554   m68k-*-coff*)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     ;;
2557   m68*-*-* | fido-*-*)
2558     libgloss_dir=m68k
2559     ;;
2560   mcore-*-pe*)
2561   # The EPOC C++ environment does not support exceptions or rtti,
2562   # and so building libstdc++-v3 tends not to always work.
2563     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2564     ;;
2565   mmix-*-*)
2566     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2567     unsupported_languages="$unsupported_languages fortran java"
2568     ;;
2569   mn10200-*-*)
2570     noconfigdirs="$noconfigdirs ${libgcj}"
2571     ;;
2572   mn10300-*-*)
2573     noconfigdirs="$noconfigdirs ${libgcj}"
2574     ;;
2575   mt-*-*)
2576     noconfigdirs="$noconfigdirs sim"
2577     ;;
2578   powerpc-*-aix*)
2579     # copied from rs6000-*-* entry
2580     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2581     ;;
2582   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2583     target_configdirs="$target_configdirs target-winsup"
2584     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2585     # always build newlib.
2586     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2587     ;;
2588     # This is temporary until we can link against shared libraries
2589   powerpcle-*-solaris*)
2590     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2591     libgloss_dir=rs6000
2592     ;;
2593   powerpc-*-beos*)
2594     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2595     ;;
2596   powerpc-*-eabi)
2597     noconfigdirs="$noconfigdirs ${libgcj}"
2598     libgloss_dir=rs6000
2599     ;;
2600   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2601     libgloss_dir=rs6000
2602     ;;
2603   rs6000-*-lynxos*)
2604     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2605     ;;
2606   rs6000-*-aix*)
2607     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp target-newlib ${libgcj}"
2608     ;;
2609   rs6000-*-*)
2610     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2611     ;;
2612   m68k-apollo-*)
2613     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2614     ;;
2615   microblaze*)
2616     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2617     ;;
2618   mips*-sde-elf*)
2619     skipdirs="$skipdirs target-libiberty"
2620     noconfigdirs="$noconfigdirs ${libgcj}"
2621     if test x$with_newlib = xyes; then
2622       noconfigdirs="$noconfigdirs gprof"
2623     fi
2624     libgloss_dir=mips
2625     ;;
2626   mips*-*-irix5*)
2627     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2628     ;;
2629   mips*-*-irix6*)
2630     # Linking libjava exceeds command-line length limits on at least
2631     # IRIX 6.2, but not on IRIX 6.5.
2632     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2633     # <oldham@codesourcery.com>
2634     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2635     ;;
2636   mips*-*-bsd*)
2637     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2638     ;;
2639   mips*-*-linux*)
2640     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2641     ;;
2642   mips*-*-*)
2643     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2644     libgloss_dir=mips
2645     ;;
2646   romp-*-*)
2647     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2648     ;;
2649   sh-*-* | sh64-*-*)
2650     case "${host}" in
2651       i[3456789]86-*-vsta) ;; # don't add gprof back in
2652       i[3456789]86-*-go32*) ;; # don't add gprof back in
2653       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2654       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2655     esac
2656     case "${target}" in
2657       sh*-*-elf)
2658          noconfigdirs="$noconfigdirs ${libgcj}" ;;
2659       *)
2660          noconfigdirs="$noconfigdirs target-libgloss ${libgcj}" ;;
2661     esac
2662     ;;
2663   sparclet-*-aout* | sparc86x-*-*)
2664     libgloss_dir=sparc
2665     ;;
2666   sparc-*-elf*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     ;;
2669   sparc64-*-elf*)
2670     noconfigdirs="$noconfigdirs ${libgcj}"
2671     libgloss_dir=sparc
2672     ;;
2673   sparclite-*-*)
2674     noconfigdirs="$noconfigdirs ${libgcj}"
2675     libgloss_dir=sparc
2676     ;;
2677   sparc-*-sunos4*)
2678     noconfigdirs="$noconfigdirs ${libgcj}"
2679     if test x${is_cross_compiler} != xno ; then
2680            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2681     else
2682            use_gnu_ld=no
2683     fi
2684     ;;
2685   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2686     noconfigdirs="$noconfigdirs ${libgcj}"
2687     ;;
2688   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2689     ;;
2690   v810-*-*)
2691     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2692     ;;
2693   v850-*-*)
2694     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2695     ;;
2696   v850e-*-*)
2697     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2698     ;;
2699   v850ea-*-*)
2700     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2701     ;;
2702   vax-*-vms)
2703     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2704     ;;
2705   vax-*-*)
2706     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2707     ;;
2708   xtensa*-*-*)
2709     noconfigdirs="$noconfigdirs ${libgcj}"
2710     ;;
2711   ip2k-*-*)
2712     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2713     ;;
2714   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2715     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2716     ;;
2717   *-*-lynxos*)
2718     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2719     ;;
2720   *-*-*)
2721     noconfigdirs="$noconfigdirs ${libgcj}"
2722     ;;
2723 esac
2724
2725 # If we aren't building newlib, then don't build libgloss, since libgloss
2726 # depends upon some newlib header files.
2727 case "${noconfigdirs}" in
2728   *target-libgloss*) ;;
2729   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2730 esac
2731
2732 # Work in distributions that contain no compiler tools, like Autoconf.
2733 tentative_cc=""
2734 host_makefile_frag=/dev/null
2735 if test -d ${srcdir}/config ; then
2736 case "${host}" in
2737   m68k-hp-hpux*)
2738     # Avoid "too much defining" errors from HPUX compiler.
2739     tentative_cc="cc -Wp,-H256000"
2740     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2741     # If it's HP/UX ar, this should be harmless.
2742     RANLIB="ar ts"
2743     ;;
2744   m68k-apollo-sysv*)
2745     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2746     ;;
2747   m68k-apollo-bsd*)
2748     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2749     # chokes on bfd, the compiler won't let you assign integers to enums, and
2750     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2751     # the apollo compiler" (the preferred version of GCC could be called cc,
2752     # or whatever), but I'm not sure leaving CC as cc is any better...
2753     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2754     # Used to have BISON=yacc.
2755     tentative_cc=gcc
2756     ;;
2757   m88k-dg-dgux*)
2758     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2759     ;;
2760   m88k-harris-cxux*)
2761     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2762     tentative_cc="cc -Xa"
2763     host_makefile_frag="config/mh-cxux"
2764     ;;
2765   m88k-motorola-sysv*)
2766     ;;
2767   mips*-dec-ultrix*)
2768     tentative_cc="cc -Wf,-XNg1000"
2769     host_makefile_frag="config/mh-decstation"
2770     ;;
2771   mips*-nec-sysv4*)
2772     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2773     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2774     host_makefile_frag="config/mh-necv4"
2775     ;;
2776   mips*-sgi-irix4*)
2777     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2778     # environment.  Also bump switch table size so that cp-parse will
2779     # compile.  Bump string length limit so linker builds.
2780     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2781     ;;
2782   mips*-*-sysv4*)
2783     host_makefile_frag="config/mh-sysv4"
2784     ;;
2785   mips*-*-sysv*)
2786     # This is for a MIPS running RISC/os 4.52C.
2787
2788     # This is needed for GDB, but needs to be in the top-level make because
2789     # if a library is compiled with the bsd headers and gets linked with the
2790     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2791     # a different size).
2792     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2793     # known except to select the sysv environment.  Could we use /proc instead?
2794     # These "sysv environments" and "bsd environments" often end up being a pain.
2795     #
2796     # This is not part of CFLAGS because perhaps not all C compilers have this
2797     # option.
2798     tentative_cc="cc -systype sysv"
2799     ;;
2800   i370-ibm-opened*)
2801     tentative_cc="c89"
2802     ;;
2803   i[3456789]86-*-sysv5*)
2804     host_makefile_frag="config/mh-sysv5"
2805     ;;
2806   i[3456789]86-*-dgux*)
2807     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2808     host_makefile_frag="config/mh-dgux386"
2809     ;;
2810   i[3456789]86-ncr-sysv4.3*)
2811     # The MetaWare compiler will generate a copyright message unless you
2812     # turn it off by adding the -Hnocopyr flag.
2813     tentative_cc="cc -Hnocopyr"
2814     ;;
2815   i[3456789]86-ncr-sysv4*)
2816     # for an NCR 3000 (i486/SVR4) system.
2817     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2818     # This compiler not only emits obnoxious copyright messages every time
2819     # you run it, but it chokes and dies on a whole bunch of GNU source
2820     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2821     tentative_cc="/usr/ccs/ATT/cc"
2822     host_makefile_frag="config/mh-ncr3000"
2823     ;;
2824   i[3456789]86-*-sco3.2v5*)
2825     ;;
2826   i[3456789]86-*-sco*)
2827     # The native C compiler botches some simple uses of const.  Unfortunately,
2828     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2829     tentative_cc="cc -Dconst="
2830     host_makefile_frag="config/mh-sco"
2831     ;;
2832   i[3456789]86-*-udk*)
2833     host_makefile_frag="config/mh-sysv5"
2834     ;;
2835   i[3456789]86-*-solaris2*)
2836     host_makefile_frag="config/mh-sysv4"
2837     ;;
2838   i[3456789]86-*-msdosdjgpp*)
2839     host_makefile_frag="config/mh-djgpp"
2840     ;;
2841   *-cygwin*)
2842
2843 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2844 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2845 echo a >cygwin-cat-check
2846 if test `cat cygwin-cat-check` == a ; then
2847   rm cygwin-cat-check
2848   echo "$as_me:$LINENO: result: yes" >&5
2849 echo "${ECHO_T}yes" >&6
2850 else
2851   rm cygwin-cat-check
2852   echo "$as_me:$LINENO: result: no" >&5
2853 echo "${ECHO_T}no" >&6
2854   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2855   Please either mount the build directory in binary mode or run the following
2856   commands before running any configure script:
2857 set -o igncr
2858 export SHELLOPTS
2859   " >&5
2860 echo "$as_me: error: The cat command does not ignore carriage return characters.
2861   Please either mount the build directory in binary mode or run the following
2862   commands before running any configure script:
2863 set -o igncr
2864 export SHELLOPTS
2865   " >&2;}
2866    { (exit 1); exit 1; }; }
2867 fi
2868
2869     host_makefile_frag="config/mh-cygwin"
2870     ;;
2871   *-mingw*)
2872     host_makefile_frag="config/mh-mingw"
2873     ;;
2874   *-interix*)
2875     host_makefile_frag="config/mh-interix"
2876     ;;
2877   vax-*-ultrix2*)
2878     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2879     tentative_cc=gcc
2880     ;;
2881   *-*-solaris2*)
2882     host_makefile_frag="config/mh-solaris"
2883     ;;
2884   m68k-sun-sunos*)
2885     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2886     # without overflowing the jump tables (-J says to use a 32 bit table)
2887     tentative_cc="cc -J"
2888     ;;
2889   hppa*-hp-hpux10*)
2890     tentative_cc="cc -Wp,-H256000"
2891     host_makefile_frag="config/mh-pa-hpux10"
2892     ;;
2893   hppa*-hp-hpux* | hppa*-*-hiux*)
2894     tentative_cc="cc -Wp,-H256000"
2895     host_makefile_frag="config/mh-pa"
2896     ;;
2897   hppa*-*)
2898     host_makefile_frag="config/mh-pa"
2899     ;;
2900   *-hp-hpux* | *-*-hiux*)
2901     tentative_cc="cc -Wp,-H256000"
2902     ;;
2903   rs6000-*-lynxos*)
2904     # /bin/cc is less than useful for our purposes.  Always use GCC
2905     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2906     host_makefile_frag="config/mh-lynxrs6k"
2907     ;;
2908   powerpc-*-darwin*)
2909     host_makefile_frag="config/mh-ppc-darwin"
2910     ;;
2911   powerpc-*-aix*)
2912     host_makefile_frag="config/mh-ppc-aix"
2913     ;;
2914   rs6000-*-aix*)
2915     host_makefile_frag="config/mh-ppc-aix"
2916     ;;
2917   *-*-lynxos*)
2918     # /bin/cc is less than useful for our purposes.  Always use GCC
2919     tentative_cc="/bin/gcc"
2920     ;;
2921   *-*-sysv4*)
2922     host_makefile_frag="config/mh-sysv4"
2923     ;;
2924   # This is placed last to prevent interfering with the cases above.
2925   i[3456789]86-*-*)
2926     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2927     host_makefile_frag="config/mh-x86omitfp"
2928     ;;
2929 esac
2930 fi
2931
2932 # If we aren't going to be using gcc, see if we can extract a definition
2933 # of CC from the fragment.
2934 # Actually, use the 'pre-extracted' version above.
2935 if test -z "${CC}" && test "${build}" = "${host}" ; then
2936   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2937   found=
2938   for dir in $PATH; do
2939     test -z "$dir" && dir=.
2940     if test -f $dir/gcc; then
2941       found=yes
2942       break
2943     fi
2944   done
2945   IFS="$save_ifs"
2946   if test -z "${found}" && test -n "${tentative_cc}" ; then
2947     CC=$tentative_cc
2948   fi
2949 fi
2950
2951 if test "${build}" != "${host}" ; then
2952   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2953   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2954   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2955   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2956   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2957   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2958   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2959   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2960   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2961   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2962   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2963   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2964 else
2965   AR_FOR_BUILD="\$(AR)"
2966   AS_FOR_BUILD="\$(AS)"
2967   CC_FOR_BUILD="\$(CC)"
2968   CXX_FOR_BUILD="\$(CXX)"
2969   GCJ_FOR_BUILD="\$(GCJ)"
2970   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2971   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2972   LD_FOR_BUILD="\$(LD)"
2973   NM_FOR_BUILD="\$(NM)"
2974   RANLIB_FOR_BUILD="\$(RANLIB)"
2975   WINDRES_FOR_BUILD="\$(WINDRES)"
2976   WINDMC_FOR_BUILD="\$(WINDMC)"
2977 fi
2978
2979 ac_ext=c
2980 ac_cpp='$CPP $CPPFLAGS'
2981 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2982 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2983 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2984 if test -n "$ac_tool_prefix"; then
2985   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2986 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2987 echo "$as_me:$LINENO: checking for $ac_word" >&5
2988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2989 if test "${ac_cv_prog_CC+set}" = set; then
2990   echo $ECHO_N "(cached) $ECHO_C" >&6
2991 else
2992   if test -n "$CC"; then
2993   ac_cv_prog_CC="$CC" # Let the user override the test.
2994 else
2995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2996 for as_dir in $PATH
2997 do
2998   IFS=$as_save_IFS
2999   test -z "$as_dir" && as_dir=.
3000   for ac_exec_ext in '' $ac_executable_extensions; do
3001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3002     ac_cv_prog_CC="${ac_tool_prefix}gcc"
3003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3004     break 2
3005   fi
3006 done
3007 done
3008
3009 fi
3010 fi
3011 CC=$ac_cv_prog_CC
3012 if test -n "$CC"; then
3013   echo "$as_me:$LINENO: result: $CC" >&5
3014 echo "${ECHO_T}$CC" >&6
3015 else
3016   echo "$as_me:$LINENO: result: no" >&5
3017 echo "${ECHO_T}no" >&6
3018 fi
3019
3020 fi
3021 if test -z "$ac_cv_prog_CC"; then
3022   ac_ct_CC=$CC
3023   # Extract the first word of "gcc", so it can be a program name with args.
3024 set dummy gcc; ac_word=$2
3025 echo "$as_me:$LINENO: checking for $ac_word" >&5
3026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3027 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3028   echo $ECHO_N "(cached) $ECHO_C" >&6
3029 else
3030   if test -n "$ac_ct_CC"; then
3031   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3032 else
3033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3034 for as_dir in $PATH
3035 do
3036   IFS=$as_save_IFS
3037   test -z "$as_dir" && as_dir=.
3038   for ac_exec_ext in '' $ac_executable_extensions; do
3039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3040     ac_cv_prog_ac_ct_CC="gcc"
3041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3042     break 2
3043   fi
3044 done
3045 done
3046
3047 fi
3048 fi
3049 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3050 if test -n "$ac_ct_CC"; then
3051   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3052 echo "${ECHO_T}$ac_ct_CC" >&6
3053 else
3054   echo "$as_me:$LINENO: result: no" >&5
3055 echo "${ECHO_T}no" >&6
3056 fi
3057
3058   CC=$ac_ct_CC
3059 else
3060   CC="$ac_cv_prog_CC"
3061 fi
3062
3063 if test -z "$CC"; then
3064   if test -n "$ac_tool_prefix"; then
3065   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3066 set dummy ${ac_tool_prefix}cc; ac_word=$2
3067 echo "$as_me:$LINENO: checking for $ac_word" >&5
3068 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3069 if test "${ac_cv_prog_CC+set}" = set; then
3070   echo $ECHO_N "(cached) $ECHO_C" >&6
3071 else
3072   if test -n "$CC"; then
3073   ac_cv_prog_CC="$CC" # Let the user override the test.
3074 else
3075 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3076 for as_dir in $PATH
3077 do
3078   IFS=$as_save_IFS
3079   test -z "$as_dir" && as_dir=.
3080   for ac_exec_ext in '' $ac_executable_extensions; do
3081   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3082     ac_cv_prog_CC="${ac_tool_prefix}cc"
3083     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3084     break 2
3085   fi
3086 done
3087 done
3088
3089 fi
3090 fi
3091 CC=$ac_cv_prog_CC
3092 if test -n "$CC"; then
3093   echo "$as_me:$LINENO: result: $CC" >&5
3094 echo "${ECHO_T}$CC" >&6
3095 else
3096   echo "$as_me:$LINENO: result: no" >&5
3097 echo "${ECHO_T}no" >&6
3098 fi
3099
3100 fi
3101 if test -z "$ac_cv_prog_CC"; then
3102   ac_ct_CC=$CC
3103   # Extract the first word of "cc", so it can be a program name with args.
3104 set dummy cc; ac_word=$2
3105 echo "$as_me:$LINENO: checking for $ac_word" >&5
3106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3107 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3108   echo $ECHO_N "(cached) $ECHO_C" >&6
3109 else
3110   if test -n "$ac_ct_CC"; then
3111   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3112 else
3113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3114 for as_dir in $PATH
3115 do
3116   IFS=$as_save_IFS
3117   test -z "$as_dir" && as_dir=.
3118   for ac_exec_ext in '' $ac_executable_extensions; do
3119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3120     ac_cv_prog_ac_ct_CC="cc"
3121     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3122     break 2
3123   fi
3124 done
3125 done
3126
3127 fi
3128 fi
3129 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3130 if test -n "$ac_ct_CC"; then
3131   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3132 echo "${ECHO_T}$ac_ct_CC" >&6
3133 else
3134   echo "$as_me:$LINENO: result: no" >&5
3135 echo "${ECHO_T}no" >&6
3136 fi
3137
3138   CC=$ac_ct_CC
3139 else
3140   CC="$ac_cv_prog_CC"
3141 fi
3142
3143 fi
3144 if test -z "$CC"; then
3145   # Extract the first word of "cc", so it can be a program name with args.
3146 set dummy cc; ac_word=$2
3147 echo "$as_me:$LINENO: checking for $ac_word" >&5
3148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3149 if test "${ac_cv_prog_CC+set}" = set; then
3150   echo $ECHO_N "(cached) $ECHO_C" >&6
3151 else
3152   if test -n "$CC"; then
3153   ac_cv_prog_CC="$CC" # Let the user override the test.
3154 else
3155   ac_prog_rejected=no
3156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3157 for as_dir in $PATH
3158 do
3159   IFS=$as_save_IFS
3160   test -z "$as_dir" && as_dir=.
3161   for ac_exec_ext in '' $ac_executable_extensions; do
3162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3163     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3164        ac_prog_rejected=yes
3165        continue
3166      fi
3167     ac_cv_prog_CC="cc"
3168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3169     break 2
3170   fi
3171 done
3172 done
3173
3174 if test $ac_prog_rejected = yes; then
3175   # We found a bogon in the path, so make sure we never use it.
3176   set dummy $ac_cv_prog_CC
3177   shift
3178   if test $# != 0; then
3179     # We chose a different compiler from the bogus one.
3180     # However, it has the same basename, so the bogon will be chosen
3181     # first if we set CC to just the basename; use the full file name.
3182     shift
3183     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3184   fi
3185 fi
3186 fi
3187 fi
3188 CC=$ac_cv_prog_CC
3189 if test -n "$CC"; then
3190   echo "$as_me:$LINENO: result: $CC" >&5
3191 echo "${ECHO_T}$CC" >&6
3192 else
3193   echo "$as_me:$LINENO: result: no" >&5
3194 echo "${ECHO_T}no" >&6
3195 fi
3196
3197 fi
3198 if test -z "$CC"; then
3199   if test -n "$ac_tool_prefix"; then
3200   for ac_prog in cl
3201   do
3202     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3203 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3204 echo "$as_me:$LINENO: checking for $ac_word" >&5
3205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3206 if test "${ac_cv_prog_CC+set}" = set; then
3207   echo $ECHO_N "(cached) $ECHO_C" >&6
3208 else
3209   if test -n "$CC"; then
3210   ac_cv_prog_CC="$CC" # Let the user override the test.
3211 else
3212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3213 for as_dir in $PATH
3214 do
3215   IFS=$as_save_IFS
3216   test -z "$as_dir" && as_dir=.
3217   for ac_exec_ext in '' $ac_executable_extensions; do
3218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3219     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3221     break 2
3222   fi
3223 done
3224 done
3225
3226 fi
3227 fi
3228 CC=$ac_cv_prog_CC
3229 if test -n "$CC"; then
3230   echo "$as_me:$LINENO: result: $CC" >&5
3231 echo "${ECHO_T}$CC" >&6
3232 else
3233   echo "$as_me:$LINENO: result: no" >&5
3234 echo "${ECHO_T}no" >&6
3235 fi
3236
3237     test -n "$CC" && break
3238   done
3239 fi
3240 if test -z "$CC"; then
3241   ac_ct_CC=$CC
3242   for ac_prog in cl
3243 do
3244   # Extract the first word of "$ac_prog", so it can be a program name with args.
3245 set dummy $ac_prog; ac_word=$2
3246 echo "$as_me:$LINENO: checking for $ac_word" >&5
3247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3248 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3249   echo $ECHO_N "(cached) $ECHO_C" >&6
3250 else
3251   if test -n "$ac_ct_CC"; then
3252   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3253 else
3254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3255 for as_dir in $PATH
3256 do
3257   IFS=$as_save_IFS
3258   test -z "$as_dir" && as_dir=.
3259   for ac_exec_ext in '' $ac_executable_extensions; do
3260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3261     ac_cv_prog_ac_ct_CC="$ac_prog"
3262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3263     break 2
3264   fi
3265 done
3266 done
3267
3268 fi
3269 fi
3270 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3271 if test -n "$ac_ct_CC"; then
3272   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3273 echo "${ECHO_T}$ac_ct_CC" >&6
3274 else
3275   echo "$as_me:$LINENO: result: no" >&5
3276 echo "${ECHO_T}no" >&6
3277 fi
3278
3279   test -n "$ac_ct_CC" && break
3280 done
3281
3282   CC=$ac_ct_CC
3283 fi
3284
3285 fi
3286
3287
3288 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3289 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3290 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3291 See \`config.log' for more details." >&5
3292 echo "$as_me: error: no acceptable C compiler found in \$PATH
3293 See \`config.log' for more details." >&2;}
3294    { (exit 1); exit 1; }; }; }
3295
3296 # Provide some information about the compiler.
3297 echo "$as_me:$LINENO:" \
3298      "checking for C compiler version" >&5
3299 ac_compiler=`set X $ac_compile; echo $2`
3300 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3301   (eval $ac_compiler --version </dev/null >&5) 2>&5
3302   ac_status=$?
3303   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3304   (exit $ac_status); }
3305 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3306   (eval $ac_compiler -v </dev/null >&5) 2>&5
3307   ac_status=$?
3308   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3309   (exit $ac_status); }
3310 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3311   (eval $ac_compiler -V </dev/null >&5) 2>&5
3312   ac_status=$?
3313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3314   (exit $ac_status); }
3315
3316 cat >conftest.$ac_ext <<_ACEOF
3317 /* confdefs.h.  */
3318 _ACEOF
3319 cat confdefs.h >>conftest.$ac_ext
3320 cat >>conftest.$ac_ext <<_ACEOF
3321 /* end confdefs.h.  */
3322
3323 int
3324 main ()
3325 {
3326
3327   ;
3328   return 0;
3329 }
3330 _ACEOF
3331 ac_clean_files_save=$ac_clean_files
3332 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3333 # Try to create an executable without -o first, disregard a.out.
3334 # It will help us diagnose broken compilers, and finding out an intuition
3335 # of exeext.
3336 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3337 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3338 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3339 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3340   (eval $ac_link_default) 2>&5
3341   ac_status=$?
3342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3343   (exit $ac_status); }; then
3344   # Find the output, starting from the most likely.  This scheme is
3345 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3346 # resort.
3347
3348 # Be careful to initialize this variable, since it used to be cached.
3349 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3350 ac_cv_exeext=
3351 # b.out is created by i960 compilers.
3352 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3353 do
3354   test -f "$ac_file" || continue
3355   case $ac_file in
3356     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3357         ;;
3358     conftest.$ac_ext )
3359         # This is the source file.
3360         ;;
3361     [ab].out )
3362         # We found the default executable, but exeext='' is most
3363         # certainly right.
3364         break;;
3365     *.* )
3366         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3367         # FIXME: I believe we export ac_cv_exeext for Libtool,
3368         # but it would be cool to find out if it's true.  Does anybody
3369         # maintain Libtool? --akim.
3370         export ac_cv_exeext
3371         break;;
3372     * )
3373         break;;
3374   esac
3375 done
3376 else
3377   echo "$as_me: failed program was:" >&5
3378 sed 's/^/| /' conftest.$ac_ext >&5
3379
3380 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3381 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3382 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3383 See \`config.log' for more details." >&5
3384 echo "$as_me: error: C compiler cannot create executables
3385 See \`config.log' for more details." >&2;}
3386    { (exit 77); exit 77; }; }; }
3387 fi
3388
3389 ac_exeext=$ac_cv_exeext
3390 echo "$as_me:$LINENO: result: $ac_file" >&5
3391 echo "${ECHO_T}$ac_file" >&6
3392
3393 # Check the compiler produces executables we can run.  If not, either
3394 # the compiler is broken, or we cross compile.
3395 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3396 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3397 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3398 # If not cross compiling, check that we can run a simple program.
3399 if test "$cross_compiling" != yes; then
3400   if { ac_try='./$ac_file'
3401   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3402   (eval $ac_try) 2>&5
3403   ac_status=$?
3404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3405   (exit $ac_status); }; }; then
3406     cross_compiling=no
3407   else
3408     if test "$cross_compiling" = maybe; then
3409         cross_compiling=yes
3410     else
3411         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3412 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3413 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3414 If you meant to cross compile, use \`--host'.
3415 See \`config.log' for more details." >&5
3416 echo "$as_me: error: cannot run C compiled programs.
3417 If you meant to cross compile, use \`--host'.
3418 See \`config.log' for more details." >&2;}
3419    { (exit 1); exit 1; }; }; }
3420     fi
3421   fi
3422 fi
3423 echo "$as_me:$LINENO: result: yes" >&5
3424 echo "${ECHO_T}yes" >&6
3425
3426 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3427 ac_clean_files=$ac_clean_files_save
3428 # Check the compiler produces executables we can run.  If not, either
3429 # the compiler is broken, or we cross compile.
3430 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3431 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3432 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3433 echo "${ECHO_T}$cross_compiling" >&6
3434
3435 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3436 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3437 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3438   (eval $ac_link) 2>&5
3439   ac_status=$?
3440   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3441   (exit $ac_status); }; then
3442   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3443 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3444 # work properly (i.e., refer to `conftest.exe'), while it won't with
3445 # `rm'.
3446 for ac_file in conftest.exe conftest conftest.*; do
3447   test -f "$ac_file" || continue
3448   case $ac_file in
3449     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3450     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3451           export ac_cv_exeext
3452           break;;
3453     * ) break;;
3454   esac
3455 done
3456 else
3457   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3458 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3459 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3460 See \`config.log' for more details." >&5
3461 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3462 See \`config.log' for more details." >&2;}
3463    { (exit 1); exit 1; }; }; }
3464 fi
3465
3466 rm -f conftest$ac_cv_exeext
3467 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3468 echo "${ECHO_T}$ac_cv_exeext" >&6
3469
3470 rm -f conftest.$ac_ext
3471 EXEEXT=$ac_cv_exeext
3472 ac_exeext=$EXEEXT
3473 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3474 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3475 if test "${ac_cv_objext+set}" = set; then
3476   echo $ECHO_N "(cached) $ECHO_C" >&6
3477 else
3478   cat >conftest.$ac_ext <<_ACEOF
3479 /* confdefs.h.  */
3480 _ACEOF
3481 cat confdefs.h >>conftest.$ac_ext
3482 cat >>conftest.$ac_ext <<_ACEOF
3483 /* end confdefs.h.  */
3484
3485 int
3486 main ()
3487 {
3488
3489   ;
3490   return 0;
3491 }
3492 _ACEOF
3493 rm -f conftest.o conftest.obj
3494 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3495   (eval $ac_compile) 2>&5
3496   ac_status=$?
3497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3498   (exit $ac_status); }; then
3499   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3500   case $ac_file in
3501     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3502     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3503        break;;
3504   esac
3505 done
3506 else
3507   echo "$as_me: failed program was:" >&5
3508 sed 's/^/| /' conftest.$ac_ext >&5
3509
3510 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3511 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3512 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3513 See \`config.log' for more details." >&5
3514 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3515 See \`config.log' for more details." >&2;}
3516    { (exit 1); exit 1; }; }; }
3517 fi
3518
3519 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3520 fi
3521 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3522 echo "${ECHO_T}$ac_cv_objext" >&6
3523 OBJEXT=$ac_cv_objext
3524 ac_objext=$OBJEXT
3525 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3526 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3527 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3528   echo $ECHO_N "(cached) $ECHO_C" >&6
3529 else
3530   cat >conftest.$ac_ext <<_ACEOF
3531 /* confdefs.h.  */
3532 _ACEOF
3533 cat confdefs.h >>conftest.$ac_ext
3534 cat >>conftest.$ac_ext <<_ACEOF
3535 /* end confdefs.h.  */
3536
3537 int
3538 main ()
3539 {
3540 #ifndef __GNUC__
3541        choke me
3542 #endif
3543
3544   ;
3545   return 0;
3546 }
3547 _ACEOF
3548 rm -f conftest.$ac_objext
3549 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3550   (eval $ac_compile) 2>conftest.er1
3551   ac_status=$?
3552   grep -v '^ *+' conftest.er1 >conftest.err
3553   rm -f conftest.er1
3554   cat conftest.err >&5
3555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556   (exit $ac_status); } &&
3557          { ac_try='test -z "$ac_c_werror_flag"
3558                          || test ! -s conftest.err'
3559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3560   (eval $ac_try) 2>&5
3561   ac_status=$?
3562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3563   (exit $ac_status); }; } &&
3564          { ac_try='test -s conftest.$ac_objext'
3565   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3566   (eval $ac_try) 2>&5
3567   ac_status=$?
3568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3569   (exit $ac_status); }; }; then
3570   ac_compiler_gnu=yes
3571 else
3572   echo "$as_me: failed program was:" >&5
3573 sed 's/^/| /' conftest.$ac_ext >&5
3574
3575 ac_compiler_gnu=no
3576 fi
3577 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3578 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3579
3580 fi
3581 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3582 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3583 GCC=`test $ac_compiler_gnu = yes && echo yes`
3584 ac_test_CFLAGS=${CFLAGS+set}
3585 ac_save_CFLAGS=$CFLAGS
3586 CFLAGS="-g"
3587 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3588 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3589 if test "${ac_cv_prog_cc_g+set}" = set; then
3590   echo $ECHO_N "(cached) $ECHO_C" >&6
3591 else
3592   cat >conftest.$ac_ext <<_ACEOF
3593 /* confdefs.h.  */
3594 _ACEOF
3595 cat confdefs.h >>conftest.$ac_ext
3596 cat >>conftest.$ac_ext <<_ACEOF
3597 /* end confdefs.h.  */
3598
3599 int
3600 main ()
3601 {
3602
3603   ;
3604   return 0;
3605 }
3606 _ACEOF
3607 rm -f conftest.$ac_objext
3608 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3609   (eval $ac_compile) 2>conftest.er1
3610   ac_status=$?
3611   grep -v '^ *+' conftest.er1 >conftest.err
3612   rm -f conftest.er1
3613   cat conftest.err >&5
3614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3615   (exit $ac_status); } &&
3616          { ac_try='test -z "$ac_c_werror_flag"
3617                          || test ! -s conftest.err'
3618   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3619   (eval $ac_try) 2>&5
3620   ac_status=$?
3621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3622   (exit $ac_status); }; } &&
3623          { ac_try='test -s conftest.$ac_objext'
3624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3625   (eval $ac_try) 2>&5
3626   ac_status=$?
3627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3628   (exit $ac_status); }; }; then
3629   ac_cv_prog_cc_g=yes
3630 else
3631   echo "$as_me: failed program was:" >&5
3632 sed 's/^/| /' conftest.$ac_ext >&5
3633
3634 ac_cv_prog_cc_g=no
3635 fi
3636 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3637 fi
3638 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3639 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3640 if test "$ac_test_CFLAGS" = set; then
3641   CFLAGS=$ac_save_CFLAGS
3642 elif test $ac_cv_prog_cc_g = yes; then
3643   if test "$GCC" = yes; then
3644     CFLAGS="-g -O2"
3645   else
3646     CFLAGS="-g"
3647   fi
3648 else
3649   if test "$GCC" = yes; then
3650     CFLAGS="-O2"
3651   else
3652     CFLAGS=
3653   fi
3654 fi
3655 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3656 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3657 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3658   echo $ECHO_N "(cached) $ECHO_C" >&6
3659 else
3660   ac_cv_prog_cc_stdc=no
3661 ac_save_CC=$CC
3662 cat >conftest.$ac_ext <<_ACEOF
3663 /* confdefs.h.  */
3664 _ACEOF
3665 cat confdefs.h >>conftest.$ac_ext
3666 cat >>conftest.$ac_ext <<_ACEOF
3667 /* end confdefs.h.  */
3668 #include <stdarg.h>
3669 #include <stdio.h>
3670 #include <sys/types.h>
3671 #include <sys/stat.h>
3672 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3673 struct buf { int x; };
3674 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3675 static char *e (p, i)
3676      char **p;
3677      int i;
3678 {
3679   return p[i];
3680 }
3681 static char *f (char * (*g) (char **, int), char **p, ...)
3682 {
3683   char *s;
3684   va_list v;
3685   va_start (v,p);
3686   s = g (p, va_arg (v,int));
3687   va_end (v);
3688   return s;
3689 }
3690
3691 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3692    function prototypes and stuff, but not '\xHH' hex character constants.
3693    These don't provoke an error unfortunately, instead are silently treated
3694    as 'x'.  The following induces an error, until -std1 is added to get
3695    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3696    array size at least.  It's necessary to write '\x00'==0 to get something
3697    that's true only with -std1.  */
3698 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3699
3700 int test (int i, double x);
3701 struct s1 {int (*f) (int a);};
3702 struct s2 {int (*f) (double a);};
3703 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3704 int argc;
3705 char **argv;
3706 int
3707 main ()
3708 {
3709 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3710   ;
3711   return 0;
3712 }
3713 _ACEOF
3714 # Don't try gcc -ansi; that turns off useful extensions and
3715 # breaks some systems' header files.
3716 # AIX                   -qlanglvl=ansi
3717 # Ultrix and OSF/1      -std1
3718 # HP-UX 10.20 and later -Ae
3719 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3720 # SVR4                  -Xc -D__EXTENSIONS__
3721 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3722 do
3723   CC="$ac_save_CC $ac_arg"
3724   rm -f conftest.$ac_objext
3725 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3726   (eval $ac_compile) 2>conftest.er1
3727   ac_status=$?
3728   grep -v '^ *+' conftest.er1 >conftest.err
3729   rm -f conftest.er1
3730   cat conftest.err >&5
3731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3732   (exit $ac_status); } &&
3733          { ac_try='test -z "$ac_c_werror_flag"
3734                          || test ! -s conftest.err'
3735   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3736   (eval $ac_try) 2>&5
3737   ac_status=$?
3738   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3739   (exit $ac_status); }; } &&
3740          { ac_try='test -s conftest.$ac_objext'
3741   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3742   (eval $ac_try) 2>&5
3743   ac_status=$?
3744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745   (exit $ac_status); }; }; then
3746   ac_cv_prog_cc_stdc=$ac_arg
3747 break
3748 else
3749   echo "$as_me: failed program was:" >&5
3750 sed 's/^/| /' conftest.$ac_ext >&5
3751
3752 fi
3753 rm -f conftest.err conftest.$ac_objext
3754 done
3755 rm -f conftest.$ac_ext conftest.$ac_objext
3756 CC=$ac_save_CC
3757
3758 fi
3759
3760 case "x$ac_cv_prog_cc_stdc" in
3761   x|xno)
3762     echo "$as_me:$LINENO: result: none needed" >&5
3763 echo "${ECHO_T}none needed" >&6 ;;
3764   *)
3765     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3766 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3767     CC="$CC $ac_cv_prog_cc_stdc" ;;
3768 esac
3769
3770 # Some people use a C++ compiler to compile C.  Since we use `exit',
3771 # in C++ we need to declare it.  In case someone uses the same compiler
3772 # for both compiling C and C++ we need to have the C++ compiler decide
3773 # the declaration of exit, since it's the most demanding environment.
3774 cat >conftest.$ac_ext <<_ACEOF
3775 #ifndef __cplusplus
3776   choke me
3777 #endif
3778 _ACEOF
3779 rm -f conftest.$ac_objext
3780 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3781   (eval $ac_compile) 2>conftest.er1
3782   ac_status=$?
3783   grep -v '^ *+' conftest.er1 >conftest.err
3784   rm -f conftest.er1
3785   cat conftest.err >&5
3786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787   (exit $ac_status); } &&
3788          { ac_try='test -z "$ac_c_werror_flag"
3789                          || test ! -s conftest.err'
3790   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3791   (eval $ac_try) 2>&5
3792   ac_status=$?
3793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794   (exit $ac_status); }; } &&
3795          { ac_try='test -s conftest.$ac_objext'
3796   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3797   (eval $ac_try) 2>&5
3798   ac_status=$?
3799   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800   (exit $ac_status); }; }; then
3801   for ac_declaration in \
3802    '' \
3803    'extern "C" void std::exit (int) throw (); using std::exit;' \
3804    'extern "C" void std::exit (int); using std::exit;' \
3805    'extern "C" void exit (int) throw ();' \
3806    'extern "C" void exit (int);' \
3807    'void exit (int);'
3808 do
3809   cat >conftest.$ac_ext <<_ACEOF
3810 /* confdefs.h.  */
3811 _ACEOF
3812 cat confdefs.h >>conftest.$ac_ext
3813 cat >>conftest.$ac_ext <<_ACEOF
3814 /* end confdefs.h.  */
3815 $ac_declaration
3816 #include <stdlib.h>
3817 int
3818 main ()
3819 {
3820 exit (42);
3821   ;
3822   return 0;
3823 }
3824 _ACEOF
3825 rm -f conftest.$ac_objext
3826 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3827   (eval $ac_compile) 2>conftest.er1
3828   ac_status=$?
3829   grep -v '^ *+' conftest.er1 >conftest.err
3830   rm -f conftest.er1
3831   cat conftest.err >&5
3832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3833   (exit $ac_status); } &&
3834          { ac_try='test -z "$ac_c_werror_flag"
3835                          || test ! -s conftest.err'
3836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3837   (eval $ac_try) 2>&5
3838   ac_status=$?
3839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3840   (exit $ac_status); }; } &&
3841          { ac_try='test -s conftest.$ac_objext'
3842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3843   (eval $ac_try) 2>&5
3844   ac_status=$?
3845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3846   (exit $ac_status); }; }; then
3847   :
3848 else
3849   echo "$as_me: failed program was:" >&5
3850 sed 's/^/| /' conftest.$ac_ext >&5
3851
3852 continue
3853 fi
3854 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3855   cat >conftest.$ac_ext <<_ACEOF
3856 /* confdefs.h.  */
3857 _ACEOF
3858 cat confdefs.h >>conftest.$ac_ext
3859 cat >>conftest.$ac_ext <<_ACEOF
3860 /* end confdefs.h.  */
3861 $ac_declaration
3862 int
3863 main ()
3864 {
3865 exit (42);
3866   ;
3867   return 0;
3868 }
3869 _ACEOF
3870 rm -f conftest.$ac_objext
3871 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3872   (eval $ac_compile) 2>conftest.er1
3873   ac_status=$?
3874   grep -v '^ *+' conftest.er1 >conftest.err
3875   rm -f conftest.er1
3876   cat conftest.err >&5
3877   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3878   (exit $ac_status); } &&
3879          { ac_try='test -z "$ac_c_werror_flag"
3880                          || test ! -s conftest.err'
3881   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3882   (eval $ac_try) 2>&5
3883   ac_status=$?
3884   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3885   (exit $ac_status); }; } &&
3886          { ac_try='test -s conftest.$ac_objext'
3887   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3888   (eval $ac_try) 2>&5
3889   ac_status=$?
3890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3891   (exit $ac_status); }; }; then
3892   break
3893 else
3894   echo "$as_me: failed program was:" >&5
3895 sed 's/^/| /' conftest.$ac_ext >&5
3896
3897 fi
3898 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3899 done
3900 rm -f conftest*
3901 if test -n "$ac_declaration"; then
3902   echo '#ifdef __cplusplus' >>confdefs.h
3903   echo $ac_declaration      >>confdefs.h
3904   echo '#endif'             >>confdefs.h
3905 fi
3906
3907 else
3908   echo "$as_me: failed program was:" >&5
3909 sed 's/^/| /' conftest.$ac_ext >&5
3910
3911 fi
3912 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3913 ac_ext=c
3914 ac_cpp='$CPP $CPPFLAGS'
3915 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3916 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3917 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3918
3919 ac_ext=cc
3920 ac_cpp='$CXXCPP $CPPFLAGS'
3921 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3922 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3923 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3924 if test -n "$ac_tool_prefix"; then
3925   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3926   do
3927     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3928 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3929 echo "$as_me:$LINENO: checking for $ac_word" >&5
3930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3931 if test "${ac_cv_prog_CXX+set}" = set; then
3932   echo $ECHO_N "(cached) $ECHO_C" >&6
3933 else
3934   if test -n "$CXX"; then
3935   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3936 else
3937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3938 for as_dir in $PATH
3939 do
3940   IFS=$as_save_IFS
3941   test -z "$as_dir" && as_dir=.
3942   for ac_exec_ext in '' $ac_executable_extensions; do
3943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3944     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3946     break 2
3947   fi
3948 done
3949 done
3950
3951 fi
3952 fi
3953 CXX=$ac_cv_prog_CXX
3954 if test -n "$CXX"; then
3955   echo "$as_me:$LINENO: result: $CXX" >&5
3956 echo "${ECHO_T}$CXX" >&6
3957 else
3958   echo "$as_me:$LINENO: result: no" >&5
3959 echo "${ECHO_T}no" >&6
3960 fi
3961
3962     test -n "$CXX" && break
3963   done
3964 fi
3965 if test -z "$CXX"; then
3966   ac_ct_CXX=$CXX
3967   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3968 do
3969   # Extract the first word of "$ac_prog", so it can be a program name with args.
3970 set dummy $ac_prog; ac_word=$2
3971 echo "$as_me:$LINENO: checking for $ac_word" >&5
3972 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3973 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3974   echo $ECHO_N "(cached) $ECHO_C" >&6
3975 else
3976   if test -n "$ac_ct_CXX"; then
3977   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3978 else
3979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3980 for as_dir in $PATH
3981 do
3982   IFS=$as_save_IFS
3983   test -z "$as_dir" && as_dir=.
3984   for ac_exec_ext in '' $ac_executable_extensions; do
3985   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3986     ac_cv_prog_ac_ct_CXX="$ac_prog"
3987     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3988     break 2
3989   fi
3990 done
3991 done
3992
3993 fi
3994 fi
3995 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3996 if test -n "$ac_ct_CXX"; then
3997   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3998 echo "${ECHO_T}$ac_ct_CXX" >&6
3999 else
4000   echo "$as_me:$LINENO: result: no" >&5
4001 echo "${ECHO_T}no" >&6
4002 fi
4003
4004   test -n "$ac_ct_CXX" && break
4005 done
4006 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
4007
4008   CXX=$ac_ct_CXX
4009 fi
4010
4011
4012 # Provide some information about the compiler.
4013 echo "$as_me:$LINENO:" \
4014      "checking for C++ compiler version" >&5
4015 ac_compiler=`set X $ac_compile; echo $2`
4016 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4017   (eval $ac_compiler --version </dev/null >&5) 2>&5
4018   ac_status=$?
4019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020   (exit $ac_status); }
4021 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4022   (eval $ac_compiler -v </dev/null >&5) 2>&5
4023   ac_status=$?
4024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4025   (exit $ac_status); }
4026 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4027   (eval $ac_compiler -V </dev/null >&5) 2>&5
4028   ac_status=$?
4029   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4030   (exit $ac_status); }
4031
4032 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4033 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4034 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4035   echo $ECHO_N "(cached) $ECHO_C" >&6
4036 else
4037   cat >conftest.$ac_ext <<_ACEOF
4038 /* confdefs.h.  */
4039 _ACEOF
4040 cat confdefs.h >>conftest.$ac_ext
4041 cat >>conftest.$ac_ext <<_ACEOF
4042 /* end confdefs.h.  */
4043
4044 int
4045 main ()
4046 {
4047 #ifndef __GNUC__
4048        choke me
4049 #endif
4050
4051   ;
4052   return 0;
4053 }
4054 _ACEOF
4055 rm -f conftest.$ac_objext
4056 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4057   (eval $ac_compile) 2>conftest.er1
4058   ac_status=$?
4059   grep -v '^ *+' conftest.er1 >conftest.err
4060   rm -f conftest.er1
4061   cat conftest.err >&5
4062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4063   (exit $ac_status); } &&
4064          { ac_try='test -z "$ac_cxx_werror_flag"
4065                          || test ! -s conftest.err'
4066   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4067   (eval $ac_try) 2>&5
4068   ac_status=$?
4069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4070   (exit $ac_status); }; } &&
4071          { ac_try='test -s conftest.$ac_objext'
4072   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4073   (eval $ac_try) 2>&5
4074   ac_status=$?
4075   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4076   (exit $ac_status); }; }; then
4077   ac_compiler_gnu=yes
4078 else
4079   echo "$as_me: failed program was:" >&5
4080 sed 's/^/| /' conftest.$ac_ext >&5
4081
4082 ac_compiler_gnu=no
4083 fi
4084 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4085 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4086
4087 fi
4088 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4089 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4090 GXX=`test $ac_compiler_gnu = yes && echo yes`
4091 ac_test_CXXFLAGS=${CXXFLAGS+set}
4092 ac_save_CXXFLAGS=$CXXFLAGS
4093 CXXFLAGS="-g"
4094 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4095 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4096 if test "${ac_cv_prog_cxx_g+set}" = set; then
4097   echo $ECHO_N "(cached) $ECHO_C" >&6
4098 else
4099   cat >conftest.$ac_ext <<_ACEOF
4100 /* confdefs.h.  */
4101 _ACEOF
4102 cat confdefs.h >>conftest.$ac_ext
4103 cat >>conftest.$ac_ext <<_ACEOF
4104 /* end confdefs.h.  */
4105
4106 int
4107 main ()
4108 {
4109
4110   ;
4111   return 0;
4112 }
4113 _ACEOF
4114 rm -f conftest.$ac_objext
4115 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4116   (eval $ac_compile) 2>conftest.er1
4117   ac_status=$?
4118   grep -v '^ *+' conftest.er1 >conftest.err
4119   rm -f conftest.er1
4120   cat conftest.err >&5
4121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4122   (exit $ac_status); } &&
4123          { ac_try='test -z "$ac_cxx_werror_flag"
4124                          || test ! -s conftest.err'
4125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4126   (eval $ac_try) 2>&5
4127   ac_status=$?
4128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4129   (exit $ac_status); }; } &&
4130          { ac_try='test -s conftest.$ac_objext'
4131   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4132   (eval $ac_try) 2>&5
4133   ac_status=$?
4134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4135   (exit $ac_status); }; }; then
4136   ac_cv_prog_cxx_g=yes
4137 else
4138   echo "$as_me: failed program was:" >&5
4139 sed 's/^/| /' conftest.$ac_ext >&5
4140
4141 ac_cv_prog_cxx_g=no
4142 fi
4143 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4144 fi
4145 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4146 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4147 if test "$ac_test_CXXFLAGS" = set; then
4148   CXXFLAGS=$ac_save_CXXFLAGS
4149 elif test $ac_cv_prog_cxx_g = yes; then
4150   if test "$GXX" = yes; then
4151     CXXFLAGS="-g -O2"
4152   else
4153     CXXFLAGS="-g"
4154   fi
4155 else
4156   if test "$GXX" = yes; then
4157     CXXFLAGS="-O2"
4158   else
4159     CXXFLAGS=
4160   fi
4161 fi
4162 for ac_declaration in \
4163    '' \
4164    'extern "C" void std::exit (int) throw (); using std::exit;' \
4165    'extern "C" void std::exit (int); using std::exit;' \
4166    'extern "C" void exit (int) throw ();' \
4167    'extern "C" void exit (int);' \
4168    'void exit (int);'
4169 do
4170   cat >conftest.$ac_ext <<_ACEOF
4171 /* confdefs.h.  */
4172 _ACEOF
4173 cat confdefs.h >>conftest.$ac_ext
4174 cat >>conftest.$ac_ext <<_ACEOF
4175 /* end confdefs.h.  */
4176 $ac_declaration
4177 #include <stdlib.h>
4178 int
4179 main ()
4180 {
4181 exit (42);
4182   ;
4183   return 0;
4184 }
4185 _ACEOF
4186 rm -f conftest.$ac_objext
4187 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4188   (eval $ac_compile) 2>conftest.er1
4189   ac_status=$?
4190   grep -v '^ *+' conftest.er1 >conftest.err
4191   rm -f conftest.er1
4192   cat conftest.err >&5
4193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4194   (exit $ac_status); } &&
4195          { ac_try='test -z "$ac_cxx_werror_flag"
4196                          || test ! -s conftest.err'
4197   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4198   (eval $ac_try) 2>&5
4199   ac_status=$?
4200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4201   (exit $ac_status); }; } &&
4202          { ac_try='test -s conftest.$ac_objext'
4203   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4204   (eval $ac_try) 2>&5
4205   ac_status=$?
4206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4207   (exit $ac_status); }; }; then
4208   :
4209 else
4210   echo "$as_me: failed program was:" >&5
4211 sed 's/^/| /' conftest.$ac_ext >&5
4212
4213 continue
4214 fi
4215 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4216   cat >conftest.$ac_ext <<_ACEOF
4217 /* confdefs.h.  */
4218 _ACEOF
4219 cat confdefs.h >>conftest.$ac_ext
4220 cat >>conftest.$ac_ext <<_ACEOF
4221 /* end confdefs.h.  */
4222 $ac_declaration
4223 int
4224 main ()
4225 {
4226 exit (42);
4227   ;
4228   return 0;
4229 }
4230 _ACEOF
4231 rm -f conftest.$ac_objext
4232 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4233   (eval $ac_compile) 2>conftest.er1
4234   ac_status=$?
4235   grep -v '^ *+' conftest.er1 >conftest.err
4236   rm -f conftest.er1
4237   cat conftest.err >&5
4238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4239   (exit $ac_status); } &&
4240          { ac_try='test -z "$ac_cxx_werror_flag"
4241                          || test ! -s conftest.err'
4242   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4243   (eval $ac_try) 2>&5
4244   ac_status=$?
4245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4246   (exit $ac_status); }; } &&
4247          { ac_try='test -s conftest.$ac_objext'
4248   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4249   (eval $ac_try) 2>&5
4250   ac_status=$?
4251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4252   (exit $ac_status); }; }; then
4253   break
4254 else
4255   echo "$as_me: failed program was:" >&5
4256 sed 's/^/| /' conftest.$ac_ext >&5
4257
4258 fi
4259 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4260 done
4261 rm -f conftest*
4262 if test -n "$ac_declaration"; then
4263   echo '#ifdef __cplusplus' >>confdefs.h
4264   echo $ac_declaration      >>confdefs.h
4265   echo '#endif'             >>confdefs.h
4266 fi
4267
4268 ac_ext=c
4269 ac_cpp='$CPP $CPPFLAGS'
4270 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4271 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4272 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4273
4274
4275 # We must set the default linker to the linker used by gcc for the correct
4276 # operation of libtool.  If LD is not defined and we are using gcc, try to
4277 # set the LD default to the ld used by gcc.
4278 if test -z "$LD"; then
4279   if test "$GCC" = yes; then
4280     case $build in
4281     *-*-mingw*)
4282       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4283     *)
4284       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4285     esac
4286     case $gcc_prog_ld in
4287     # Accept absolute paths.
4288     [\\/]* | [A-Za-z]:[\\/]*)
4289       LD="$gcc_prog_ld" ;;
4290     esac
4291   fi
4292 fi
4293
4294
4295
4296
4297 if test -n "$ac_tool_prefix"; then
4298   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4299 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4300 echo "$as_me:$LINENO: checking for $ac_word" >&5
4301 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4302 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4303   echo $ECHO_N "(cached) $ECHO_C" >&6
4304 else
4305   if test -n "$GNATBIND"; then
4306   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4307 else
4308 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4309 for as_dir in $PATH
4310 do
4311   IFS=$as_save_IFS
4312   test -z "$as_dir" && as_dir=.
4313   for ac_exec_ext in '' $ac_executable_extensions; do
4314   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4315     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4316     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4317     break 2
4318   fi
4319 done
4320 done
4321
4322 fi
4323 fi
4324 GNATBIND=$ac_cv_prog_GNATBIND
4325 if test -n "$GNATBIND"; then
4326   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4327 echo "${ECHO_T}$GNATBIND" >&6
4328 else
4329   echo "$as_me:$LINENO: result: no" >&5
4330 echo "${ECHO_T}no" >&6
4331 fi
4332
4333 fi
4334 if test -z "$ac_cv_prog_GNATBIND"; then
4335   ac_ct_GNATBIND=$GNATBIND
4336   # Extract the first word of "gnatbind", so it can be a program name with args.
4337 set dummy gnatbind; ac_word=$2
4338 echo "$as_me:$LINENO: checking for $ac_word" >&5
4339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4340 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4341   echo $ECHO_N "(cached) $ECHO_C" >&6
4342 else
4343   if test -n "$ac_ct_GNATBIND"; then
4344   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4345 else
4346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4347 for as_dir in $PATH
4348 do
4349   IFS=$as_save_IFS
4350   test -z "$as_dir" && as_dir=.
4351   for ac_exec_ext in '' $ac_executable_extensions; do
4352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4353     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4355     break 2
4356   fi
4357 done
4358 done
4359
4360   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4361 fi
4362 fi
4363 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4364 if test -n "$ac_ct_GNATBIND"; then
4365   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4366 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4367 else
4368   echo "$as_me:$LINENO: result: no" >&5
4369 echo "${ECHO_T}no" >&6
4370 fi
4371
4372   GNATBIND=$ac_ct_GNATBIND
4373 else
4374   GNATBIND="$ac_cv_prog_GNATBIND"
4375 fi
4376
4377 if test -n "$ac_tool_prefix"; then
4378   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4379 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4380 echo "$as_me:$LINENO: checking for $ac_word" >&5
4381 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4382 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4383   echo $ECHO_N "(cached) $ECHO_C" >&6
4384 else
4385   if test -n "$GNATMAKE"; then
4386   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4387 else
4388 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4389 for as_dir in $PATH
4390 do
4391   IFS=$as_save_IFS
4392   test -z "$as_dir" && as_dir=.
4393   for ac_exec_ext in '' $ac_executable_extensions; do
4394   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4395     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4396     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4397     break 2
4398   fi
4399 done
4400 done
4401
4402 fi
4403 fi
4404 GNATMAKE=$ac_cv_prog_GNATMAKE
4405 if test -n "$GNATMAKE"; then
4406   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4407 echo "${ECHO_T}$GNATMAKE" >&6
4408 else
4409   echo "$as_me:$LINENO: result: no" >&5
4410 echo "${ECHO_T}no" >&6
4411 fi
4412
4413 fi
4414 if test -z "$ac_cv_prog_GNATMAKE"; then
4415   ac_ct_GNATMAKE=$GNATMAKE
4416   # Extract the first word of "gnatmake", so it can be a program name with args.
4417 set dummy gnatmake; ac_word=$2
4418 echo "$as_me:$LINENO: checking for $ac_word" >&5
4419 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4420 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4421   echo $ECHO_N "(cached) $ECHO_C" >&6
4422 else
4423   if test -n "$ac_ct_GNATMAKE"; then
4424   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4425 else
4426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4427 for as_dir in $PATH
4428 do
4429   IFS=$as_save_IFS
4430   test -z "$as_dir" && as_dir=.
4431   for ac_exec_ext in '' $ac_executable_extensions; do
4432   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4433     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4434     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4435     break 2
4436   fi
4437 done
4438 done
4439
4440   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4441 fi
4442 fi
4443 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4444 if test -n "$ac_ct_GNATMAKE"; then
4445   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4446 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4447 else
4448   echo "$as_me:$LINENO: result: no" >&5
4449 echo "${ECHO_T}no" >&6
4450 fi
4451
4452   GNATMAKE=$ac_ct_GNATMAKE
4453 else
4454   GNATMAKE="$ac_cv_prog_GNATMAKE"
4455 fi
4456
4457 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4458 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4459 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4460   echo $ECHO_N "(cached) $ECHO_C" >&6
4461 else
4462   cat >conftest.adb <<EOF
4463 procedure conftest is begin null; end conftest;
4464 EOF
4465 acx_cv_cc_gcc_supports_ada=no
4466 # There is a bug in old released versions of GCC which causes the
4467 # driver to exit successfully when the appropriate language module
4468 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4469 # Therefore we must check for the error message as well as an
4470 # unsuccessful exit.
4471 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4472 # given a .adb file, but produce no object file.  So we must check
4473 # if an object file was really produced to guard against this.
4474 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4475 if test x"$errors" = x && test -f conftest.$ac_objext; then
4476   acx_cv_cc_gcc_supports_ada=yes
4477 fi
4478 rm -f conftest.*
4479 fi
4480 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4481 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4482
4483 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4484   have_gnat=yes
4485 else
4486   have_gnat=no
4487 fi
4488
4489 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4490 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4491 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4492   echo $ECHO_N "(cached) $ECHO_C" >&6
4493 else
4494    echo abfoo >t1
4495   echo cdfoo >t2
4496   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4497   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4498     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4499       :
4500     else
4501       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4502     fi
4503   fi
4504   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4505     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4506       :
4507     else
4508       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4509     fi
4510   fi
4511   rm t1 t2
4512
4513 fi
4514 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4515 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4516 do_compare="$gcc_cv_prog_cmp_skip"
4517
4518
4519
4520 # See if we are building gcc with C++.
4521 # Check whether --enable-build-with-cxx or --disable-build-with-cxx was given.
4522 if test "${enable_build_with_cxx+set}" = set; then
4523   enableval="$enable_build_with_cxx"
4524   ENABLE_BUILD_WITH_CXX=$enableval
4525 else
4526   ENABLE_BUILD_WITH_CXX=no
4527 fi;
4528
4529 # Check for GMP, MPFR and MPC
4530 gmplibs="-lmpfr -lgmp"
4531 gmpinc=
4532 have_gmp=no
4533 mpclibs=-lmpc
4534 mpcinc=
4535 have_mpc=no
4536
4537 # Specify a location for mpc
4538 # check for this first so it ends up on the link line before mpfr.
4539
4540 # Check whether --with-mpc or --without-mpc was given.
4541 if test "${with_mpc+set}" = set; then
4542   withval="$with_mpc"
4543
4544 fi;
4545
4546 # Check whether --with-mpc_include or --without-mpc_include was given.
4547 if test "${with_mpc_include+set}" = set; then
4548   withval="$with_mpc_include"
4549
4550 fi;
4551
4552 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4553 if test "${with_mpc_lib+set}" = set; then
4554   withval="$with_mpc_lib"
4555
4556 fi;
4557
4558 if test "x$with_mpc" != x; then
4559   mpclibs="-L$with_mpc/lib -lmpc"
4560   mpcinc="-I$with_mpc/include $mpcinc"
4561 fi
4562 if test "x$with_mpc_include" != x; then
4563   mpcinc="-I$with_mpc_include $mpcinc"
4564 fi
4565 if test "x$with_mpc_lib" != x; then
4566   mpclibs="-L$with_mpc_lib -lmpc"
4567 fi
4568 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4569   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4570   mpcinc='-I$$s/mpc/src '"$mpcinc"
4571   # Do not test the mpc version.  Assume that it is sufficient, since
4572   # it is in the source tree, and the library has not been built yet
4573   # but it would be included on the link line in the version check below
4574   # hence making the test fail.
4575   have_mpc=yes
4576 fi
4577
4578 # Specify a location for mpfr
4579 # check for this first so it ends up on the link line before gmp.
4580
4581 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4582 if test "${with_mpfr_dir+set}" = set; then
4583   withval="$with_mpfr_dir"
4584   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4585 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4586 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4587 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4588    { (exit 1); exit 1; }; }
4589 fi;
4590
4591
4592 # Check whether --with-mpfr or --without-mpfr was given.
4593 if test "${with_mpfr+set}" = set; then
4594   withval="$with_mpfr"
4595
4596 fi;
4597
4598 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4599 if test "${with_mpfr_include+set}" = set; then
4600   withval="$with_mpfr_include"
4601
4602 fi;
4603
4604 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4605 if test "${with_mpfr_lib+set}" = set; then
4606   withval="$with_mpfr_lib"
4607
4608 fi;
4609
4610 if test "x$with_mpfr" != x; then
4611   gmplibs="-L$with_mpfr/lib $gmplibs"
4612   gmpinc="-I$with_mpfr/include"
4613 fi
4614 if test "x$with_mpfr_include" != x; then
4615   gmpinc="-I$with_mpfr_include"
4616 fi
4617 if test "x$with_mpfr_lib" != x; then
4618   gmplibs="-L$with_mpfr_lib $gmplibs"
4619 fi
4620 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4621   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4622   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4623   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4624   # Do not test the mpfr version.  Assume that it is sufficient, since
4625   # it is in the source tree, and the library has not been built yet
4626   # but it would be included on the link line in the version check below
4627   # hence making the test fail.
4628   have_gmp=yes
4629 fi
4630
4631 # Specify a location for gmp
4632
4633 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4634 if test "${with_gmp_dir+set}" = set; then
4635   withval="$with_gmp_dir"
4636   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4637 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4638 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4639 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4640    { (exit 1); exit 1; }; }
4641 fi;
4642
4643
4644 # Check whether --with-gmp or --without-gmp was given.
4645 if test "${with_gmp+set}" = set; then
4646   withval="$with_gmp"
4647
4648 fi;
4649
4650 # Check whether --with-gmp_include or --without-gmp_include was given.
4651 if test "${with_gmp_include+set}" = set; then
4652   withval="$with_gmp_include"
4653
4654 fi;
4655
4656 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4657 if test "${with_gmp_lib+set}" = set; then
4658   withval="$with_gmp_lib"
4659
4660 fi;
4661
4662
4663 if test "x$with_gmp" != x; then
4664   gmplibs="-L$with_gmp/lib $gmplibs"
4665   gmpinc="-I$with_gmp/include $gmpinc"
4666 fi
4667 if test "x$with_gmp_include" != x; then
4668   gmpinc="-I$with_gmp_include $gmpinc"
4669 fi
4670 if test "x$with_gmp_lib" != x; then
4671   gmplibs="-L$with_gmp_lib $gmplibs"
4672 fi
4673 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4674   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4675   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4676   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4677   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4678   # Do not test the gmp version.  Assume that it is sufficient, since
4679   # it is in the source tree, and the library has not been built yet
4680   # but it would be included on the link line in the version check below
4681   # hence making the test fail.
4682   have_gmp=yes
4683 fi
4684
4685 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4686   have_gmp=yes
4687   saved_CFLAGS="$CFLAGS"
4688   CFLAGS="$CFLAGS $gmpinc"
4689   # Check GMP actually works
4690   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4691 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4692
4693 cat >conftest.$ac_ext <<_ACEOF
4694 /* confdefs.h.  */
4695 _ACEOF
4696 cat confdefs.h >>conftest.$ac_ext
4697 cat >>conftest.$ac_ext <<_ACEOF
4698 /* end confdefs.h.  */
4699 #include "gmp.h"
4700 int
4701 main ()
4702 {
4703
4704   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4705   choke me
4706   #endif
4707
4708   ;
4709   return 0;
4710 }
4711 _ACEOF
4712 rm -f conftest.$ac_objext
4713 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4714   (eval $ac_compile) 2>conftest.er1
4715   ac_status=$?
4716   grep -v '^ *+' conftest.er1 >conftest.err
4717   rm -f conftest.er1
4718   cat conftest.err >&5
4719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4720   (exit $ac_status); } &&
4721          { ac_try='test -z "$ac_c_werror_flag"
4722                          || test ! -s conftest.err'
4723   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4724   (eval $ac_try) 2>&5
4725   ac_status=$?
4726   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4727   (exit $ac_status); }; } &&
4728          { ac_try='test -s conftest.$ac_objext'
4729   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4730   (eval $ac_try) 2>&5
4731   ac_status=$?
4732   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4733   (exit $ac_status); }; }; then
4734   echo "$as_me:$LINENO: result: yes" >&5
4735 echo "${ECHO_T}yes" >&6
4736 else
4737   echo "$as_me: failed program was:" >&5
4738 sed 's/^/| /' conftest.$ac_ext >&5
4739
4740 echo "$as_me:$LINENO: result: no" >&5
4741 echo "${ECHO_T}no" >&6; have_gmp=no
4742 fi
4743 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4744
4745   # If we have GMP, check the MPFR version.
4746   if test x"$have_gmp" = xyes; then
4747         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4748 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4749     cat >conftest.$ac_ext <<_ACEOF
4750 /* confdefs.h.  */
4751 _ACEOF
4752 cat confdefs.h >>conftest.$ac_ext
4753 cat >>conftest.$ac_ext <<_ACEOF
4754 /* end confdefs.h.  */
4755 #include <gmp.h>
4756     #include <mpfr.h>
4757 int
4758 main ()
4759 {
4760
4761     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4762     choke me
4763     #endif
4764
4765   ;
4766   return 0;
4767 }
4768 _ACEOF
4769 rm -f conftest.$ac_objext
4770 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4771   (eval $ac_compile) 2>conftest.er1
4772   ac_status=$?
4773   grep -v '^ *+' conftest.er1 >conftest.err
4774   rm -f conftest.er1
4775   cat conftest.err >&5
4776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4777   (exit $ac_status); } &&
4778          { ac_try='test -z "$ac_c_werror_flag"
4779                          || test ! -s conftest.err'
4780   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4781   (eval $ac_try) 2>&5
4782   ac_status=$?
4783   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4784   (exit $ac_status); }; } &&
4785          { ac_try='test -s conftest.$ac_objext'
4786   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4787   (eval $ac_try) 2>&5
4788   ac_status=$?
4789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4790   (exit $ac_status); }; }; then
4791   cat >conftest.$ac_ext <<_ACEOF
4792 /* confdefs.h.  */
4793 _ACEOF
4794 cat confdefs.h >>conftest.$ac_ext
4795 cat >>conftest.$ac_ext <<_ACEOF
4796 /* end confdefs.h.  */
4797 #include <gmp.h>
4798     #include <mpfr.h>
4799 int
4800 main ()
4801 {
4802
4803     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4804     choke me
4805     #endif
4806
4807   ;
4808   return 0;
4809 }
4810 _ACEOF
4811 rm -f conftest.$ac_objext
4812 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4813   (eval $ac_compile) 2>conftest.er1
4814   ac_status=$?
4815   grep -v '^ *+' conftest.er1 >conftest.err
4816   rm -f conftest.er1
4817   cat conftest.err >&5
4818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4819   (exit $ac_status); } &&
4820          { ac_try='test -z "$ac_c_werror_flag"
4821                          || test ! -s conftest.err'
4822   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4823   (eval $ac_try) 2>&5
4824   ac_status=$?
4825   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4826   (exit $ac_status); }; } &&
4827          { ac_try='test -s conftest.$ac_objext'
4828   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4829   (eval $ac_try) 2>&5
4830   ac_status=$?
4831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4832   (exit $ac_status); }; }; then
4833   echo "$as_me:$LINENO: result: yes" >&5
4834 echo "${ECHO_T}yes" >&6
4835 else
4836   echo "$as_me: failed program was:" >&5
4837 sed 's/^/| /' conftest.$ac_ext >&5
4838
4839 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4840 echo "${ECHO_T}buggy but acceptable" >&6
4841 fi
4842 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4843 else
4844   echo "$as_me: failed program was:" >&5
4845 sed 's/^/| /' conftest.$ac_ext >&5
4846
4847 echo "$as_me:$LINENO: result: no" >&5
4848 echo "${ECHO_T}no" >&6; have_gmp=no
4849 fi
4850 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4851   fi
4852
4853   # Check for the MPC header version.
4854   if test x"$have_mpc" != xyes ; then
4855     CFLAGS="$CFLAGS $mpcinc"
4856     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4857 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4858     cat >conftest.$ac_ext <<_ACEOF
4859 /* confdefs.h.  */
4860 _ACEOF
4861 cat confdefs.h >>conftest.$ac_ext
4862 cat >>conftest.$ac_ext <<_ACEOF
4863 /* end confdefs.h.  */
4864 #include <mpc.h>
4865 int
4866 main ()
4867 {
4868
4869     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4870     choke me
4871     #endif
4872
4873   ;
4874   return 0;
4875 }
4876 _ACEOF
4877 rm -f conftest.$ac_objext
4878 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4879   (eval $ac_compile) 2>conftest.er1
4880   ac_status=$?
4881   grep -v '^ *+' conftest.er1 >conftest.err
4882   rm -f conftest.er1
4883   cat conftest.err >&5
4884   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4885   (exit $ac_status); } &&
4886          { ac_try='test -z "$ac_c_werror_flag"
4887                          || test ! -s conftest.err'
4888   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4889   (eval $ac_try) 2>&5
4890   ac_status=$?
4891   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4892   (exit $ac_status); }; } &&
4893          { ac_try='test -s conftest.$ac_objext'
4894   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4895   (eval $ac_try) 2>&5
4896   ac_status=$?
4897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4898   (exit $ac_status); }; }; then
4899   echo "$as_me:$LINENO: result: yes" >&5
4900 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4901 else
4902   echo "$as_me: failed program was:" >&5
4903 sed 's/^/| /' conftest.$ac_ext >&5
4904
4905 echo "$as_me:$LINENO: result: no" >&5
4906 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4907 fi
4908 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4909   fi
4910
4911   # Now check the MPFR library.
4912   if test x"$have_gmp" = xyes; then
4913     saved_LIBS="$LIBS"
4914     LIBS="$LIBS $gmplibs"
4915     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4916 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4917     cat >conftest.$ac_ext <<_ACEOF
4918 /* confdefs.h.  */
4919 _ACEOF
4920 cat confdefs.h >>conftest.$ac_ext
4921 cat >>conftest.$ac_ext <<_ACEOF
4922 /* end confdefs.h.  */
4923 #include <gmp.h>
4924     #include <mpfr.h>
4925 int
4926 main ()
4927 {
4928
4929     mpfr_t n;
4930     mpfr_t x;
4931     int t;
4932     mpfr_init (n);
4933     mpfr_init (x);
4934     mpfr_atan2 (n, n, x, GMP_RNDN);
4935     mpfr_erfc (n, x, GMP_RNDN);
4936     mpfr_subnormalize (x, t, GMP_RNDN);
4937
4938   ;
4939   return 0;
4940 }
4941 _ACEOF
4942 rm -f conftest.$ac_objext conftest$ac_exeext
4943 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4944   (eval $ac_link) 2>conftest.er1
4945   ac_status=$?
4946   grep -v '^ *+' conftest.er1 >conftest.err
4947   rm -f conftest.er1
4948   cat conftest.err >&5
4949   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4950   (exit $ac_status); } &&
4951          { ac_try='test -z "$ac_c_werror_flag"
4952                          || test ! -s conftest.err'
4953   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4954   (eval $ac_try) 2>&5
4955   ac_status=$?
4956   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4957   (exit $ac_status); }; } &&
4958          { ac_try='test -s conftest$ac_exeext'
4959   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4960   (eval $ac_try) 2>&5
4961   ac_status=$?
4962   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4963   (exit $ac_status); }; }; then
4964   echo "$as_me:$LINENO: result: yes" >&5
4965 echo "${ECHO_T}yes" >&6
4966 else
4967   echo "$as_me: failed program was:" >&5
4968 sed 's/^/| /' conftest.$ac_ext >&5
4969
4970 echo "$as_me:$LINENO: result: no" >&5
4971 echo "${ECHO_T}no" >&6; have_gmp=no
4972 fi
4973 rm -f conftest.err conftest.$ac_objext \
4974       conftest$ac_exeext conftest.$ac_ext
4975     LIBS="$saved_LIBS"
4976   fi
4977
4978   if test x"$have_mpc" = xmaybe; then
4979     saved_LIBS="$LIBS"
4980     LIBS="$LIBS $mpclibs $gmplibs"
4981     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4982 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4983     cat >conftest.$ac_ext <<_ACEOF
4984 /* confdefs.h.  */
4985 _ACEOF
4986 cat confdefs.h >>conftest.$ac_ext
4987 cat >>conftest.$ac_ext <<_ACEOF
4988 /* end confdefs.h.  */
4989 #include <mpc.h>
4990 int
4991 main ()
4992 {
4993
4994     mpc_t n;
4995     mpc_init2 (n, 53);
4996     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
4997     mpc_sin (n, n, MPC_RNDNN);
4998     mpc_cos (n, n, MPC_RNDNN);
4999     mpc_tan (n, n, MPC_RNDNN);
5000     mpc_sinh (n, n, MPC_RNDNN);
5001     mpc_cosh (n, n, MPC_RNDNN);
5002     mpc_tanh (n, n, MPC_RNDNN);
5003     mpc_exp (n, n, MPC_RNDNN);
5004     mpc_log (n, n, MPC_RNDNN);
5005     mpc_sqrt (n, n, MPC_RNDNN);
5006     mpc_proj (n, n, MPC_RNDNN);
5007     mpc_neg (n, n, MPC_RNDNN);
5008     mpc_sqr (n, n, MPC_RNDNN);
5009     mpc_clear (n);
5010
5011   ;
5012   return 0;
5013 }
5014 _ACEOF
5015 rm -f conftest.$ac_objext conftest$ac_exeext
5016 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
5017   (eval $ac_link) 2>conftest.er1
5018   ac_status=$?
5019   grep -v '^ *+' conftest.er1 >conftest.err
5020   rm -f conftest.er1
5021   cat conftest.err >&5
5022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5023   (exit $ac_status); } &&
5024          { ac_try='test -z "$ac_c_werror_flag"
5025                          || test ! -s conftest.err'
5026   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5027   (eval $ac_try) 2>&5
5028   ac_status=$?
5029   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5030   (exit $ac_status); }; } &&
5031          { ac_try='test -s conftest$ac_exeext'
5032   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5033   (eval $ac_try) 2>&5
5034   ac_status=$?
5035   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5036   (exit $ac_status); }; }; then
5037   echo "$as_me:$LINENO: result: yes" >&5
5038 echo "${ECHO_T}yes" >&6; have_mpc=yes
5039 else
5040   echo "$as_me: failed program was:" >&5
5041 sed 's/^/| /' conftest.$ac_ext >&5
5042
5043 echo "$as_me:$LINENO: result: no" >&5
5044 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5045 fi
5046 rm -f conftest.err conftest.$ac_objext \
5047       conftest$ac_exeext conftest.$ac_ext
5048     LIBS="$saved_LIBS"
5049   fi
5050
5051   CFLAGS="$saved_CFLAGS"
5052
5053   if test x$have_gmp != xyes; then
5054     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5055 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5056 Copies of these libraries' source code can be found at their respective
5057 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5058 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5059 If you obtained GMP and/or MPFR from a vendor distribution package, make
5060 sure that you have installed both the libraries and the header files.
5061 They may be located in separate packages." >&5
5062 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5063 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5064 Copies of these libraries' source code can be found at their respective
5065 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5066 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5067 If you obtained GMP and/or MPFR from a vendor distribution package, make
5068 sure that you have installed both the libraries and the header files.
5069 They may be located in separate packages." >&2;}
5070    { (exit 1); exit 1; }; }
5071   fi
5072 fi
5073
5074 if test x$have_mpc != xyes ; then
5075   mpcinc=
5076   mpclibs=
5077 fi
5078
5079 gmpinc="$mpcinc $gmpinc"
5080 gmplibs="$mpclibs $gmplibs"
5081
5082 # Flags needed for both GMP, MPFR and/or MPC.
5083
5084
5085
5086
5087
5088
5089 # Allow host libstdc++ to be specified for static linking with PPL.
5090
5091 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5092 if test "${with_host_libstdcxx+set}" = set; then
5093   withval="$with_host_libstdcxx"
5094
5095 fi;
5096
5097 case $with_host_libstdcxx in
5098   no|yes)
5099     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5100 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5101    { (exit 1); exit 1; }; }
5102     ;;
5103 esac
5104
5105 # Linker flags to use for stage1 or when not boostrapping.
5106
5107 # Check whether --with-stage1-ldflags or --without-stage1-ldflags was given.
5108 if test "${with_stage1_ldflags+set}" = set; then
5109   withval="$with_stage1_ldflags"
5110   if test "$withval" = "no" -o "$withval" = "yes"; then
5111    stage1_ldflags=
5112  else
5113    stage1_ldflags=$withval
5114  fi
5115 else
5116   stage1_ldflags=
5117 fi;
5118
5119
5120 # Libraries to use for stage1 or when not bootstrapping.
5121
5122 # Check whether --with-stage1-libs or --without-stage1-libs was given.
5123 if test "${with_stage1_libs+set}" = set; then
5124   withval="$with_stage1_libs"
5125   if test "$withval" = "no" -o "$withval" = "yes"; then
5126    stage1_libs=
5127  else
5128    stage1_libs=$withval
5129  fi
5130 else
5131   stage1_libs=$with_host_libstdcxx
5132 fi;
5133
5134
5135 # Linker flags to use for stage2 and later builds.
5136
5137 # Check whether --with-boot-ldflags or --without-boot-ldflags was given.
5138 if test "${with_boot_ldflags+set}" = set; then
5139   withval="$with_boot_ldflags"
5140   if test "$withval" = "no" -o "$withval" = "yes"; then
5141    poststage1_ldflags=
5142  else
5143    poststage1_ldflags=$withval
5144  fi
5145 else
5146   if test "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5147    poststage1_ldflags=-static-libstdc++
5148  else
5149    poststage1_ldflags=
5150  fi
5151 fi;
5152
5153
5154 # Libraries to use for stage2 and later builds.  This defaults to the
5155 # argument passed to --with-host-libstdcxx.
5156
5157 # Check whether --with-boot-libs or --without-boot-libs was given.
5158 if test "${with_boot_libs+set}" = set; then
5159   withval="$with_boot_libs"
5160   if test "$withval" = "no" -o "$withval" = "yes"; then
5161    poststage1_libs=
5162  else
5163    poststage1_libs=$withval
5164  fi
5165 else
5166   poststage1_libs=$with_host_libstdcxx
5167 fi;
5168
5169
5170 # Check for PPL
5171 ppl_major_version=0
5172 ppl_minor_version=10
5173 ppllibs=" -lppl_c -lppl -lgmpxx"
5174 pplinc=
5175
5176
5177 # Check whether --with-ppl or --without-ppl was given.
5178 if test "${with_ppl+set}" = set; then
5179   withval="$with_ppl"
5180
5181 else
5182   with_ppl=no
5183 fi;
5184
5185 # Check whether --with-ppl_include or --without-ppl_include was given.
5186 if test "${with_ppl_include+set}" = set; then
5187   withval="$with_ppl_include"
5188
5189 fi;
5190
5191 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5192 if test "${with_ppl_lib+set}" = set; then
5193   withval="$with_ppl_lib"
5194
5195 fi;
5196
5197 case $with_ppl in
5198   no)
5199     ppllibs=
5200     ;;
5201   *)
5202     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
5203     pplinc="-I$with_ppl/include $pplinc"
5204     LIBS="$ppllibs $LIBS"
5205     ;;
5206 esac
5207 if test "x$with_ppl_include" != x; then
5208   pplinc="-I$with_ppl_include $pplinc"
5209 fi
5210 if test "x$with_ppl_lib" != x; then
5211   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
5212   LIBS="$ppllibs $LIBS"
5213 fi
5214 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5215   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
5216   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5217   LIBS="$ppllibs $LIBS"
5218 fi
5219
5220 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5221 if test "${enable_ppl_version_check+set}" = set; then
5222   enableval="$enable_ppl_version_check"
5223   ENABLE_PPL_CHECK=$enableval
5224 else
5225   ENABLE_PPL_CHECK=yes
5226 fi;
5227
5228 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5229   saved_CFLAGS="$CFLAGS"
5230   CFLAGS="$CFLAGS $pplinc $gmpinc"
5231   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5232 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5233   cat >conftest.$ac_ext <<_ACEOF
5234 /* confdefs.h.  */
5235 _ACEOF
5236 cat confdefs.h >>conftest.$ac_ext
5237 cat >>conftest.$ac_ext <<_ACEOF
5238 /* end confdefs.h.  */
5239 #include "ppl_c.h"
5240 int
5241 main ()
5242 {
5243
5244   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5245   choke me
5246   #endif
5247
5248   ;
5249   return 0;
5250 }
5251 _ACEOF
5252 rm -f conftest.$ac_objext
5253 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5254   (eval $ac_compile) 2>conftest.er1
5255   ac_status=$?
5256   grep -v '^ *+' conftest.er1 >conftest.err
5257   rm -f conftest.er1
5258   cat conftest.err >&5
5259   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5260   (exit $ac_status); } &&
5261          { ac_try='test -z "$ac_c_werror_flag"
5262                          || test ! -s conftest.err'
5263   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5264   (eval $ac_try) 2>&5
5265   ac_status=$?
5266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5267   (exit $ac_status); }; } &&
5268          { ac_try='test -s conftest.$ac_objext'
5269   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5270   (eval $ac_try) 2>&5
5271   ac_status=$?
5272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5273   (exit $ac_status); }; }; then
5274   echo "$as_me:$LINENO: result: yes" >&5
5275 echo "${ECHO_T}yes" >&6
5276 else
5277   echo "$as_me: failed program was:" >&5
5278 sed 's/^/| /' conftest.$ac_ext >&5
5279
5280 echo "$as_me:$LINENO: result: no" >&5
5281 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5282 fi
5283 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5284   CFLAGS="$saved_CFLAGS"
5285 fi
5286
5287 # Flags needed for PPL
5288
5289
5290
5291
5292 # Check for CLOOG
5293 clooglibs=" -lcloog "
5294 clooginc=" -DCLOOG_PPL_BACKEND "
5295
5296
5297 # Check whether --with-cloog or --without-cloog was given.
5298 if test "${with_cloog+set}" = set; then
5299   withval="$with_cloog"
5300
5301 else
5302   with_cloog=no
5303 fi;
5304
5305 # Check whether --with-cloog_include or --without-cloog_include was given.
5306 if test "${with_cloog_include+set}" = set; then
5307   withval="$with_cloog_include"
5308
5309 fi;
5310
5311 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5312 if test "${with_cloog_lib+set}" = set; then
5313   withval="$with_cloog_lib"
5314
5315 fi;
5316
5317 case $with_cloog in
5318   no)
5319     clooglibs=
5320     clooginc=
5321     ;;
5322   *)
5323     clooglibs="-L$with_cloog/lib -lcloog"
5324     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5325     LIBS="$clooglibs $LIBS"
5326     ;;
5327 esac
5328 if test "x$with_cloog_include" != x; then
5329   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5330 fi
5331 if test "x$with_cloog_lib" != x; then
5332   clooglibs="-L$with_cloog_lib -lcloog"
5333   LIBS="$clooglibs $LIBS"
5334 fi
5335 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5336   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5337   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5338   LIBS="$clooglibs $LIBS"
5339 fi
5340
5341 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5342 if test "${enable_cloog_version_check+set}" = set; then
5343   enableval="$enable_cloog_version_check"
5344   ENABLE_CLOOG_CHECK=$enableval
5345 else
5346   ENABLE_CLOOG_CHECK=yes
5347 fi;
5348
5349 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5350   saved_CFLAGS="$CFLAGS"
5351   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5352   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5353 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5354   cat >conftest.$ac_ext <<_ACEOF
5355 /* confdefs.h.  */
5356 _ACEOF
5357 cat confdefs.h >>conftest.$ac_ext
5358 cat >>conftest.$ac_ext <<_ACEOF
5359 /* end confdefs.h.  */
5360 #include "cloog/cloog.h"
5361 int
5362 main ()
5363 {
5364
5365   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5366   choke me
5367   #endif
5368
5369   ;
5370   return 0;
5371 }
5372 _ACEOF
5373 rm -f conftest.$ac_objext
5374 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5375   (eval $ac_compile) 2>conftest.er1
5376   ac_status=$?
5377   grep -v '^ *+' conftest.er1 >conftest.err
5378   rm -f conftest.er1
5379   cat conftest.err >&5
5380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5381   (exit $ac_status); } &&
5382          { ac_try='test -z "$ac_c_werror_flag"
5383                          || test ! -s conftest.err'
5384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5385   (eval $ac_try) 2>&5
5386   ac_status=$?
5387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5388   (exit $ac_status); }; } &&
5389          { ac_try='test -s conftest.$ac_objext'
5390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5391   (eval $ac_try) 2>&5
5392   ac_status=$?
5393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5394   (exit $ac_status); }; }; then
5395   echo "$as_me:$LINENO: result: yes" >&5
5396 echo "${ECHO_T}yes" >&6
5397 else
5398   echo "$as_me: failed program was:" >&5
5399 sed 's/^/| /' conftest.$ac_ext >&5
5400
5401 echo "$as_me:$LINENO: result: no" >&5
5402 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5403 fi
5404 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5405   CFLAGS="$saved_CFLAGS"
5406 fi
5407
5408 # Flags needed for CLOOG
5409
5410
5411
5412
5413 # By default, C is the only stage 1 language.
5414 stage1_languages=,c,
5415
5416 # Target libraries that we bootstrap.
5417 bootstrap_target_libs=,target-libgcc,
5418
5419 # Figure out what language subdirectories are present.
5420 # Look if the user specified --enable-languages="..."; if not, use
5421 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5422 # go away some day.
5423 # NB:  embedded tabs in this IF block -- do not untabify
5424 if test -d ${srcdir}/gcc; then
5425   if test x"${enable_languages+set}" != xset; then
5426     if test x"${LANGUAGES+set}" = xset; then
5427       enable_languages="${LANGUAGES}"
5428         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5429     else
5430       enable_languages=all
5431     fi
5432   else
5433     if test x"${enable_languages}" = x ||
5434        test x"${enable_languages}" = xyes;
5435        then
5436       echo configure.in: --enable-languages needs at least one language argument 1>&2
5437       exit 1
5438     fi
5439   fi
5440   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5441
5442   # 'f95' is the old name for the 'fortran' language. We issue a warning
5443   # and make the substitution.
5444   case ,${enable_languages}, in
5445     *,f95,*)
5446       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5447       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5448       ;;
5449   esac
5450
5451   # First scan to see if an enabled language requires some other language.
5452   # We assume that a given config-lang.in will list all the language
5453   # front ends it requires, even if some are required indirectly.
5454   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5455     case ${lang_frag} in
5456       ..) ;;
5457       # The odd quoting in the next line works around
5458       # an apparent bug in bash 1.12 on linux.
5459       ${srcdir}/gcc/[*]/config-lang.in) ;;
5460       *)
5461         # From the config-lang.in, get $language, $lang_requires
5462         language=
5463         lang_requires=
5464         . ${lang_frag}
5465         for other in ${lang_requires} ; do
5466           case ,${enable_languages}, in
5467             *,$other,*) ;;
5468             *,all,*) ;;
5469             *,$language,*)
5470               echo " \`$other' language required by \`$language'; enabling" 1>&2
5471               enable_languages="${enable_languages},${other}"
5472               ;;
5473           esac
5474         done
5475         ;;
5476     esac
5477   done
5478
5479   new_enable_languages=,c,
5480   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5481   potential_languages=,c,
5482
5483   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5484     case ${lang_frag} in
5485       ..) ;;
5486       # The odd quoting in the next line works around
5487       # an apparent bug in bash 1.12 on linux.
5488       ${srcdir}/gcc/[*]/config-lang.in) ;;
5489       *)
5490         # From the config-lang.in, get $language, $target_libs,
5491         # $lang_dirs, $boot_language, and $build_by_default
5492         language=
5493         target_libs=
5494         lang_dirs=
5495         subdir_requires=
5496         boot_language=no
5497         build_by_default=yes
5498         . ${lang_frag}
5499         if test x${language} = x; then
5500           echo "${lang_frag} doesn't set \$language." 1>&2
5501           exit 1
5502         fi
5503
5504         if test "$language" = "c++" -a "$ENABLE_BUILD_WITH_CXX" = "yes"; then
5505           boot_language=yes
5506         fi
5507
5508         case ,${enable_languages}, in
5509           *,${language},*)
5510             # Language was explicitly selected; include it.
5511             add_this_lang=yes
5512             ;;
5513           *,all,*)
5514             # 'all' was selected, select it if it is a default language
5515             add_this_lang=${build_by_default}
5516             ;;
5517           *)
5518             add_this_lang=no
5519             ;;
5520         esac
5521
5522         # Disable languages that need other directories if these aren't available.
5523         for i in $subdir_requires; do
5524           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5525           case ,${enable_languages}, in
5526             *,${language},*)
5527               # Specifically requested language; tell them.
5528               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5529 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5530    { (exit 1); exit 1; }; }
5531               ;;
5532             *)
5533               # Silently disable.
5534               add_this_lang=unsupported
5535               ;;
5536           esac
5537         done
5538
5539         # Disable Ada if no preexisting GNAT is available.
5540         case ,${enable_languages},:${language}:${have_gnat} in
5541           *,${language},*:ada:no)
5542             # Specifically requested language; tell them.
5543             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5544 echo "$as_me: error: GNAT is required to build $language" >&2;}
5545    { (exit 1); exit 1; }; }
5546             ;;
5547           *:ada:no)
5548             # Silently disable.
5549             add_this_lang=unsupported
5550             ;;
5551         esac
5552
5553         # Disable a language that is unsupported by the target.
5554         case " $unsupported_languages " in
5555           *" $language "*)
5556             add_this_lang=unsupported
5557             ;;
5558         esac
5559
5560         case $add_this_lang in
5561           unsupported)
5562             # Remove language-dependent dirs.
5563             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5564             ;;
5565           no)
5566             # Remove language-dependent dirs; still show language as supported.
5567             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5568             potential_languages="${potential_languages}${language},"
5569             ;;
5570           yes)
5571             new_enable_languages="${new_enable_languages}${language},"
5572             potential_languages="${potential_languages}${language},"
5573             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5574             case ${boot_language} in
5575               yes)
5576                 # Add to (comma-separated) list of stage 1 languages.
5577                 stage1_languages="${stage1_languages}${language},"
5578                 # We need to bootstrap any supporting libraries.
5579                 bootstrap_target_libs="${bootstrap_target_libs}${target_libs},"
5580                 ;;
5581             esac
5582             ;;
5583         esac
5584         ;;
5585     esac
5586   done
5587
5588   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5589 if test "${enable_stage1_languages+set}" = set; then
5590   enableval="$enable_stage1_languages"
5591   case ,${enable_stage1_languages}, in
5592     ,no,|,,)
5593       # Set it to something that will have no effect in the loop below
5594       enable_stage1_languages=c ;;
5595     ,yes,)
5596       enable_stage1_languages=`echo $new_enable_languages | \
5597         sed -e "s/^,//" -e "s/,$//" ` ;;
5598     *,all,*)
5599       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5600         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5601   esac
5602
5603   # Add "good" languages from enable_stage1_languages to stage1_languages,
5604   # while "bad" languages go in missing_languages.  Leave no duplicates.
5605   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5606     case $potential_languages in
5607       *,$i,*)
5608         case $stage1_languages in
5609           *,$i,*) ;;
5610           *) stage1_languages="$stage1_languages$i," ;;
5611         esac ;;
5612       *)
5613         case $missing_languages in
5614           *,$i,*) ;;
5615           *) missing_languages="$missing_languages$i," ;;
5616         esac ;;
5617      esac
5618   done
5619 fi;
5620
5621   # Remove leading/trailing commas that were added for simplicity
5622   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5623   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5624   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5625   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5626
5627   if test "x$missing_languages" != x; then
5628     { { echo "$as_me:$LINENO: error:
5629 The following requested languages could not be built: ${missing_languages}
5630 Supported languages are: ${potential_languages}" >&5
5631 echo "$as_me: error:
5632 The following requested languages could not be built: ${missing_languages}
5633 Supported languages are: ${potential_languages}" >&2;}
5634    { (exit 1); exit 1; }; }
5635   fi
5636   if test "x$new_enable_languages" != "x$enable_languages"; then
5637     echo The following languages will be built: ${new_enable_languages}
5638     enable_languages="$new_enable_languages"
5639   fi
5640
5641
5642   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5643 fi
5644
5645 # Handle --disable-<component> generically.
5646 for dir in $configdirs $build_configdirs $target_configdirs ; do
5647   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5648   varname=`echo $dirname | sed -e s/+/_/g`
5649   if eval test x\${enable_${varname}} "=" xno ; then
5650     noconfigdirs="$noconfigdirs $dir"
5651   fi
5652 done
5653
5654 # Check for Boehm's garbage collector
5655 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5656 if test "${enable_objc_gc+set}" = set; then
5657   enableval="$enable_objc_gc"
5658   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5659   *,objc,*:*:yes:*target-boehm-gc*)
5660     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5661 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5662    { (exit 1); exit 1; }; }
5663     ;;
5664 esac
5665 fi;
5666
5667 # Make sure we only build Boehm's garbage collector if required.
5668 case ,${enable_languages},:${enable_objc_gc} in
5669   *,objc,*:yes)
5670     # Keep target-boehm-gc if requested for Objective-C.
5671     ;;
5672   *)
5673     # Otherwise remove target-boehm-gc depending on target-libjava.
5674     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5675       noconfigdirs="$noconfigdirs target-boehm-gc"
5676     fi
5677     ;;
5678 esac
5679
5680 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5681 # $build_configdirs and $target_configdirs.
5682 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5683
5684 notsupp=""
5685 for dir in . $skipdirs $noconfigdirs ; do
5686   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5687   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5688     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5689     if test -r $srcdir/$dirname/configure ; then
5690       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5691         true
5692       else
5693         notsupp="$notsupp $dir"
5694       fi
5695     fi
5696   fi
5697   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5698     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5699     if test -r $srcdir/$dirname/configure ; then
5700       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5701         true
5702       else
5703         notsupp="$notsupp $dir"
5704       fi
5705     fi
5706   fi
5707   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5708     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5709     if test -r $srcdir/$dirname/configure ; then
5710       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5711         true
5712       else
5713         notsupp="$notsupp $dir"
5714       fi
5715     fi
5716   fi
5717 done
5718
5719 # Sometimes the tools are distributed with libiberty but with no other
5720 # libraries.  In that case, we don't want to build target-libiberty.
5721 # Don't let libgcc imply libiberty either.
5722 if test -n "${target_configdirs}" ; then
5723   libgcc=
5724   others=
5725   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5726     if test "$i" = "libgcc"; then
5727       libgcc=target-libgcc
5728     elif test "$i" != "libiberty" ; then
5729       if test -r $srcdir/$i/configure ; then
5730         others=yes;
5731         break;
5732       fi
5733     fi
5734   done
5735   if test -z "${others}" ; then
5736     target_configdirs=$libgcc
5737   fi
5738 fi
5739
5740 # Quietly strip out all directories which aren't configurable in this tree.
5741 # This relies on all configurable subdirectories being autoconfiscated, which
5742 # is now the case.
5743 build_configdirs_all="$build_configdirs"
5744 build_configdirs=
5745 for i in ${build_configdirs_all} ; do
5746   j=`echo $i | sed -e s/build-//g`
5747   if test -f ${srcdir}/$j/configure ; then
5748     build_configdirs="${build_configdirs} $i"
5749   fi
5750 done
5751
5752 configdirs_all="$configdirs"
5753 configdirs=
5754 for i in ${configdirs_all} ; do
5755   if test -f ${srcdir}/$i/configure ; then
5756     configdirs="${configdirs} $i"
5757   fi
5758 done
5759
5760 target_configdirs_all="$target_configdirs"
5761 target_configdirs=
5762 for i in ${target_configdirs_all} ; do
5763   j=`echo $i | sed -e s/target-//g`
5764   if test -f ${srcdir}/$j/configure ; then
5765     target_configdirs="${target_configdirs} $i"
5766   fi
5767 done
5768
5769 # Produce a warning message for the subdirs we can't configure.
5770 # This isn't especially interesting in the Cygnus tree, but in the individual
5771 # FSF releases, it's important to let people know when their machine isn't
5772 # supported by the one or two programs in a package.
5773
5774 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5775   # If $appdirs is non-empty, at least one of those directories must still
5776   # be configured, or we error out.  (E.g., if the gas release supports a
5777   # specified target in some subdirs but not the gas subdir, we shouldn't
5778   # pretend that all is well.)
5779   if test -n "$appdirs" ; then
5780     for dir in $appdirs ; do
5781       if test -r $dir/Makefile.in ; then
5782         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5783           appdirs=""
5784           break
5785         fi
5786         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5787           appdirs=""
5788           break
5789         fi
5790       fi
5791     done
5792     if test -n "$appdirs" ; then
5793       echo "*** This configuration is not supported by this package." 1>&2
5794       exit 1
5795     fi
5796   fi
5797   # Okay, some application will build, or we don't care to check.  Still
5798   # notify of subdirs not getting built.
5799   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5800   echo "    ${notsupp}" 1>&2
5801   echo "    (Any other directories should still work fine.)" 1>&2
5802 fi
5803
5804 case "$host" in
5805   *msdosdjgpp*)
5806     enable_gdbtk=no ;;
5807 esac
5808
5809 # To find our prefix, in gcc_cv_tool_prefix.
5810
5811 # The user is always right.
5812 if test "${PATH_SEPARATOR+set}" != set; then
5813   echo "#! /bin/sh" >conf$$.sh
5814   echo  "exit 0"   >>conf$$.sh
5815   chmod +x conf$$.sh
5816   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5817     PATH_SEPARATOR=';'
5818   else
5819     PATH_SEPARATOR=:
5820   fi
5821   rm -f conf$$.sh
5822 fi
5823
5824
5825
5826 if test "x$exec_prefix" = xNONE; then
5827         if test "x$prefix" = xNONE; then
5828                 gcc_cv_tool_prefix=$ac_default_prefix
5829         else
5830                 gcc_cv_tool_prefix=$prefix
5831         fi
5832 else
5833         gcc_cv_tool_prefix=$exec_prefix
5834 fi
5835
5836 # If there is no compiler in the tree, use the PATH only.  In any
5837 # case, if there is no compiler in the tree nobody should use
5838 # AS_FOR_TARGET and LD_FOR_TARGET.
5839 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5840     gcc_version=`cat $srcdir/gcc/BASE-VER`
5841     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5842     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5843     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5844     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5845     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5846     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5847 else
5848     gcc_cv_tool_dirs=
5849 fi
5850
5851 if test x$build = x$target && test -n "$md_exec_prefix"; then
5852         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5853 fi
5854
5855
5856
5857 copy_dirs=
5858
5859
5860 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5861 if test "${with_build_sysroot+set}" = set; then
5862   withval="$with_build_sysroot"
5863   if test x"$withval" != x ; then
5864      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5865    fi
5866 else
5867   SYSROOT_CFLAGS_FOR_TARGET=
5868 fi;
5869
5870
5871
5872 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5873 if test "${with_debug_prefix_map+set}" = set; then
5874   withval="$with_debug_prefix_map"
5875   if test x"$withval" != x; then
5876      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5877      for debug_map in $withval; do
5878        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5879      done
5880    fi
5881 else
5882   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5883 fi;
5884
5885
5886 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5887 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5888 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5889 # We want to ensure that TARGET libraries (which we know are built with
5890 # gcc) are built with "-O2 -g", so include those options when setting
5891 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5892 if test "x$CFLAGS_FOR_TARGET" = x; then
5893   CFLAGS_FOR_TARGET=$CFLAGS
5894   case " $CFLAGS " in
5895     *" -O2 "*) ;;
5896     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5897   esac
5898   case " $CFLAGS " in
5899     *" -g "* | *" -g3 "*) ;;
5900     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5901   esac
5902 fi
5903
5904
5905 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5906   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5907   case " $CXXFLAGS " in
5908     *" -O2 "*) ;;
5909     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5910   esac
5911   case " $CXXFLAGS " in
5912     *" -g "* | *" -g3 "*) ;;
5913     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5914   esac
5915 fi
5916
5917
5918 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5919 # the named directory are copied to $(tooldir)/sys-include.
5920 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5921   if test x${is_cross_compiler} = xno ; then
5922     echo 1>&2 '***' --with-headers is only supported when cross compiling
5923     exit 1
5924   fi
5925   if test x"${with_headers}" != xyes ; then
5926     x=${gcc_cv_tool_prefix}
5927     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5928   fi
5929 fi
5930
5931 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5932 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5933 # are permitted.
5934 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5935   if test x${is_cross_compiler} = xno ; then
5936     echo 1>&2 '***' --with-libs is only supported when cross compiling
5937     exit 1
5938   fi
5939   if test x"${with_libs}" != xyes ; then
5940     # Copy the libraries in reverse order, so that files in the first named
5941     # library override files in subsequent libraries.
5942     x=${gcc_cv_tool_prefix}
5943     for l in ${with_libs}; do
5944       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5945     done
5946   fi
5947 fi
5948
5949 # Set with_gnu_as and with_gnu_ld as appropriate.
5950 #
5951 # This is done by determining whether or not the appropriate directory
5952 # is available, and by checking whether or not specific configurations
5953 # have requested that this magic not happen.
5954 #
5955 # The command line options always override the explicit settings in
5956 # configure.in, and the settings in configure.in override this magic.
5957 #
5958 # If the default for a toolchain is to use GNU as and ld, and you don't
5959 # want to do that, then you should use the --without-gnu-as and
5960 # --without-gnu-ld options for the configure script.
5961
5962 if test x${use_gnu_as} = x &&
5963    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5964   with_gnu_as=yes
5965   extra_host_args="$extra_host_args --with-gnu-as"
5966 fi
5967
5968 if test x${use_gnu_ld} = x &&
5969    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5970   with_gnu_ld=yes
5971   extra_host_args="$extra_host_args --with-gnu-ld"
5972 fi
5973
5974 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5975 # can detect this case.
5976
5977 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5978   with_newlib=yes
5979   extra_host_args="$extra_host_args --with-newlib"
5980 fi
5981
5982 # Handle ${copy_dirs}
5983 set fnord ${copy_dirs}
5984 shift
5985 while test $# != 0 ; do
5986   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5987     :
5988   else
5989     echo Copying $1 to $2
5990
5991     # Use the install script to create the directory and all required
5992     # parent directories.
5993     if test -d $2 ; then
5994       :
5995     else
5996       echo >config.temp
5997       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5998     fi
5999
6000     # Copy the directory, assuming we have tar.
6001     # FIXME: Should we use B in the second tar?  Not all systems support it.
6002     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
6003
6004     # It is the responsibility of the user to correctly adjust all
6005     # symlinks.  If somebody can figure out how to handle them correctly
6006     # here, feel free to add the code.
6007
6008     echo $1 > $2/COPIED
6009   fi
6010   shift; shift
6011 done
6012
6013 # Determine a target-dependent exec_prefix that the installed
6014 # gcc will search in.  Keep this list sorted by triplet, with
6015 # the *-*-osname triplets last.
6016 md_exec_prefix=
6017 case "${target}" in
6018   alpha*-*-*vms*)
6019     md_exec_prefix=/gnu/lib/gcc-lib
6020     ;;
6021   i[34567]86-pc-msdosdjgpp*)
6022     md_exec_prefix=/dev/env/DJDIR/bin
6023     ;;
6024   i[34567]86-*-sco3.2v5*)
6025     if test $with_gnu_as = yes; then
6026       md_exec_prefix=/usr/gnu/bin
6027     else
6028       md_exec_prefix=/usr/ccs/bin/elf
6029     fi
6030     ;;
6031
6032   mn10300-*-* | \
6033   powerpc-*-chorusos* | \
6034   powerpc*-*-eabi* | \
6035   powerpc*-*-sysv* | \
6036   powerpc*-*-kaos* | \
6037   s390x-ibm-tpf*)
6038     md_exec_prefix=/usr/ccs/bin
6039     ;;
6040   sparc64-*-elf*)
6041     ;;
6042   v850*-*-*)
6043     md_exec_prefix=/usr/ccs/bin
6044     ;;
6045   xtensa*-*-elf*)
6046     ;;
6047
6048   *-*-beos* | \
6049   *-*-elf* | \
6050   *-*-hpux* | \
6051   *-*-netware* | \
6052   *-*-nto-qnx* | \
6053   *-*-rtems* | \
6054   *-*-solaris2* | \
6055   *-*-sysv[45]* | \
6056   *-*-vxworks* | \
6057   *-wrs-windiss)
6058     md_exec_prefix=/usr/ccs/bin
6059     ;;
6060 esac
6061
6062 extra_arflags_for_target=
6063 extra_nmflags_for_target=
6064 extra_ranlibflags_for_target=
6065 target_makefile_frag=/dev/null
6066 case "${target}" in
6067   mep*-*-*)
6068     target_makefile_frag="config/mt-mep"
6069     ;;
6070   spu-*-*)
6071     target_makefile_frag="config/mt-spu"
6072     ;;
6073   mips*-sde-elf*)
6074     target_makefile_frag="config/mt-sde"
6075     ;;
6076   mipsisa*-*-elfoabi*)
6077     target_makefile_frag="config/mt-mips-elfoabi"
6078     ;;
6079   mips*-*-*linux* | mips*-*-gnu*)
6080     target_makefile_frag="config/mt-mips-gnu"
6081     ;;
6082   *-*-netware*)
6083     target_makefile_frag="config/mt-netware"
6084     ;;
6085   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
6086     target_makefile_frag="config/mt-gnu"
6087     ;;
6088   *-*-aix4.[3456789]* | *-*-aix[56789].*)
6089     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
6090     # commands to handle both 32-bit and 64-bit objects.  These flags are
6091     # harmless if we're using GNU nm or ar.
6092     extra_arflags_for_target=" -X32_64"
6093     extra_nmflags_for_target=" -B -X32_64"
6094     ;;
6095   *-*-darwin*)
6096     # ranlib from Darwin requires the -c flag to look at common symbols.
6097     extra_ranlibflags_for_target=" -c"
6098     ;;
6099   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
6100     target_makefile_frag="config/mt-wince"
6101     ;;
6102 esac
6103
6104 alphaieee_frag=/dev/null
6105 case $target in
6106   alpha*-*-*)
6107     # This just makes sure to use the -mieee option to build target libs.
6108     # This should probably be set individually by each library.
6109     alphaieee_frag="config/mt-alphaieee"
6110     ;;
6111 esac
6112
6113 # If --enable-target-optspace always use -Os instead of -O2 to build
6114 # the target libraries, similarly if it is not specified, use -Os
6115 # on selected platforms.
6116 ospace_frag=/dev/null
6117 case "${enable_target_optspace}:${target}" in
6118   yes:*)
6119     ospace_frag="config/mt-ospace"
6120     ;;
6121   :d30v-*)
6122     ospace_frag="config/mt-d30v"
6123     ;;
6124   :m32r-* | :d10v-* | :fr30-*)
6125     ospace_frag="config/mt-ospace"
6126     ;;
6127   no:* | :*)
6128     ;;
6129   *)
6130     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6131     ;;
6132 esac
6133
6134 # Default to using --with-stabs for certain targets.
6135 if test x${with_stabs} = x ; then
6136   case "${target}" in
6137   mips*-*-irix[56]*)
6138     ;;
6139   mips*-*-* | alpha*-*-osf*)
6140     with_stabs=yes;
6141     extra_host_args="${extra_host_args} --with-stabs"
6142     ;;
6143   esac
6144 fi
6145
6146 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6147 # them automatically.
6148 case "${host}" in
6149   hppa*64*-*-hpux11*)
6150     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6151     ;;
6152 esac
6153
6154 # Some systems (e.g., one of the i386-aix systems the gas testers are
6155 # using) don't handle "\$" correctly, so don't use it here.
6156 tooldir='${exec_prefix}'/${target_noncanonical}
6157 build_tooldir=${tooldir}
6158
6159 # Create a .gdbinit file which runs the one in srcdir
6160 # and tells GDB to look there for source files.
6161
6162 if test -r ${srcdir}/.gdbinit ; then
6163   case ${srcdir} in
6164     .) ;;
6165     *) cat > ./.gdbinit <<EOF
6166 # ${NO_EDIT}
6167 dir ${srcdir}
6168 dir .
6169 source ${srcdir}/.gdbinit
6170 EOF
6171     ;;
6172   esac
6173 fi
6174
6175 # Make sure that the compiler is able to generate an executable.  If it
6176 # can't, we are probably in trouble.  We don't care whether we can run the
6177 # executable--we might be using a cross compiler--we only care whether it
6178 # can be created.  At this point the main configure script has set CC.
6179 we_are_ok=no
6180 echo "int main () { return 0; }" > conftest.c
6181 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6182 if test $? = 0 ; then
6183   if test -s conftest || test -s conftest.exe ; then
6184     we_are_ok=yes
6185   fi
6186 fi
6187 case $we_are_ok in
6188   no)
6189     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6190     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6191     rm -f conftest*
6192     exit 1
6193     ;;
6194 esac
6195 rm -f conftest*
6196
6197 # The Solaris /usr/ucb/cc compiler does not appear to work.
6198 case "${host}" in
6199   sparc-sun-solaris2*)
6200       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6201       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6202           could_use=
6203           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6204           if test -d /opt/cygnus/bin ; then
6205               if test "$could_use" = "" ; then
6206                   could_use="/opt/cygnus/bin"
6207               else
6208                   could_use="$could_use or /opt/cygnus/bin"
6209               fi
6210           fi
6211         if test "$could_use" = "" ; then
6212             echo "Warning: compilation may fail because you're using"
6213             echo "/usr/ucb/cc.  You should change your PATH or CC "
6214             echo "variable and rerun configure."
6215         else
6216             echo "Warning: compilation may fail because you're using"
6217             echo "/usr/ucb/cc, when you should use the C compiler from"
6218             echo "$could_use.  You should change your"
6219             echo "PATH or CC variable and rerun configure."
6220         fi
6221       fi
6222   ;;
6223 esac
6224
6225 # Decide which environment variable is used to find dynamic libraries.
6226 case "${host}" in
6227   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6228   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6229   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6230   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6231 esac
6232
6233 # On systems where the dynamic library environment variable is PATH,
6234 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6235 # built executables to PATH.
6236 if test "$RPATH_ENVVAR" = PATH; then
6237   GCC_SHLIB_SUBDIR=/shlib
6238 else
6239   GCC_SHLIB_SUBDIR=
6240 fi
6241
6242 # Record target_configdirs and the configure arguments for target and
6243 # build configuration in Makefile.
6244 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6245 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6246
6247 # Determine whether gdb needs tk/tcl or not.
6248 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6249 # and in that case we want gdb to be built without tk.  Ugh!
6250 # In fact I believe gdb is the *only* package directly dependent on tk,
6251 # so we should be able to put the 'maybe's in unconditionally and
6252 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6253 # 100% sure that that's safe though.
6254
6255 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6256 case "$enable_gdbtk" in
6257   no)
6258     GDB_TK="" ;;
6259   yes)
6260     GDB_TK="${gdb_tk}" ;;
6261   *)
6262     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6263     # distro.  Eventually someone will fix this and move Insight, nee
6264     # gdbtk to a separate directory.
6265     if test -d ${srcdir}/gdb/gdbtk ; then
6266       GDB_TK="${gdb_tk}"
6267     else
6268       GDB_TK=""
6269     fi
6270     ;;
6271 esac
6272 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6273 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6274
6275 # Strip out unwanted targets.
6276
6277 # While at that, we remove Makefiles if we were started for recursive
6278 # configuration, so that the top-level Makefile reconfigures them,
6279 # like we used to do when configure itself was recursive.
6280
6281 # Loop over modules.  $extrasub must be used with care, limiting as
6282 # much as possible the usage of range addresses.  That's because autoconf
6283 # splits the sed script to overcome limits in the number of commands,
6284 # and relying on carefully-timed sed passes may turn out to be very hard
6285 # to maintain later.  In this particular case, you just have to be careful
6286 # not to nest @if/@endif pairs, because configure will not warn you at all.
6287
6288 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6289 if test "${enable_bootstrap+set}" = set; then
6290   enableval="$enable_bootstrap"
6291
6292 else
6293   enable_bootstrap=default
6294 fi;
6295
6296 # Issue errors and warnings for invalid/strange bootstrap combinations.
6297 case "$configdirs" in
6298   *gcc*) have_compiler=yes ;;
6299   *) have_compiler=no ;;
6300 esac
6301
6302 case "$have_compiler:$host:$target:$enable_bootstrap" in
6303   *:*:*:no) ;;
6304
6305   # Default behavior.  Enable bootstrap if we have a compiler
6306   # and we are in a native configuration.
6307   yes:$build:$build:default)
6308     enable_bootstrap=yes ;;
6309
6310   *:*:*:default)
6311     enable_bootstrap=no ;;
6312
6313   # We have a compiler and we are in a native configuration, bootstrap is ok
6314   yes:$build:$build:yes)
6315     ;;
6316
6317   # Other configurations, but we have a compiler.  Assume the user knows
6318   # what he's doing.
6319   yes:*:*:yes)
6320     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6321 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6322     ;;
6323
6324   # No compiler: if they passed --enable-bootstrap explicitly, fail
6325   no:*:*:yes)
6326     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6327 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6328    { (exit 1); exit 1; }; } ;;
6329
6330   # Fail if wrong command line
6331   *)
6332     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6333 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6334    { (exit 1); exit 1; }; }
6335     ;;
6336 esac
6337
6338 # Adjust the toplevel makefile according to whether bootstrap was selected.
6339 case "$enable_bootstrap" in
6340   yes)
6341     bootstrap_suffix=bootstrap ;;
6342   no)
6343     bootstrap_suffix=no-bootstrap ;;
6344 esac
6345
6346 for module in ${build_configdirs} ; do
6347   if test -z "${no_recursion}" \
6348      && test -f ${build_subdir}/${module}/Makefile; then
6349     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6350     rm -f ${build_subdir}/${module}/Makefile
6351   fi
6352   extrasub="$extrasub
6353 /^@if build-$module\$/d
6354 /^@endif build-$module\$/d
6355 /^@if build-$module-$bootstrap_suffix\$/d
6356 /^@endif build-$module-$bootstrap_suffix\$/d"
6357 done
6358 for module in ${configdirs} ; do
6359   if test -z "${no_recursion}"; then
6360     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6361       if test -f ${file}; then
6362         echo 1>&2 "*** removing ${file} to force reconfigure"
6363         rm -f ${file}
6364       fi
6365     done
6366   fi
6367   extrasub="$extrasub
6368 /^@if $module\$/d
6369 /^@endif $module\$/d
6370 /^@if $module-$bootstrap_suffix\$/d
6371 /^@endif $module-$bootstrap_suffix\$/d"
6372 done
6373 for module in ${target_configdirs} ; do
6374   if test -z "${no_recursion}" \
6375      && test -f ${target_subdir}/${module}/Makefile; then
6376     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6377     rm -f ${target_subdir}/${module}/Makefile
6378   fi
6379
6380   # We only bootstrap target libraries listed in bootstrap_target_libs.
6381   case $bootstrap_target_libs in
6382     *,target-$module,*) target_bootstrap_suffix=$bootstrap_suffix ;;
6383     *) target_bootstrap_suffix=no-bootstrap ;;
6384   esac
6385
6386   extrasub="$extrasub
6387 /^@if target-$module\$/d
6388 /^@endif target-$module\$/d
6389 /^@if target-$module-$target_bootstrap_suffix\$/d
6390 /^@endif target-$module-$target_bootstrap_suffix\$/d"
6391 done
6392
6393 extrasub="$extrasub
6394 /^@if /,/^@endif /d"
6395
6396 # Create the serialization dependencies.  This uses a temporary file.
6397
6398 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6399 if test "${enable_serial_configure+set}" = set; then
6400   enableval="$enable_serial_configure"
6401
6402 fi;
6403
6404 case ${enable_serial_configure} in
6405   yes)
6406     enable_serial_build_configure=yes
6407     enable_serial_host_configure=yes
6408     enable_serial_target_configure=yes
6409     ;;
6410 esac
6411
6412 # These force 'configure's to be done one at a time, to avoid problems
6413 # with contention over a shared config.cache.
6414 rm -f serdep.tmp
6415 echo '# serdep.tmp' > serdep.tmp
6416 olditem=
6417 test "x${enable_serial_build_configure}" = xyes &&
6418 for item in ${build_configdirs} ; do
6419   case ${olditem} in
6420     "") ;;
6421     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6422   esac
6423   olditem=${item}
6424 done
6425 olditem=
6426 test "x${enable_serial_host_configure}" = xyes &&
6427 for item in ${configdirs} ; do
6428   case ${olditem} in
6429     "") ;;
6430     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6431   esac
6432   olditem=${item}
6433 done
6434 olditem=
6435 test "x${enable_serial_target_configure}" = xyes &&
6436 for item in ${target_configdirs} ; do
6437   case ${olditem} in
6438     "") ;;
6439     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6440   esac
6441   olditem=${item}
6442 done
6443 serialization_dependencies=serdep.tmp
6444
6445
6446 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6447 # target, nonopt, and variable assignments.  These are the ones we
6448 # might not want to pass down to subconfigures.  Also strip
6449 # program-prefix, program-suffix, and program-transform-name, so that
6450 # we can pass down a consistent program-transform-name.
6451 baseargs=
6452 keep_next=no
6453 skip_next=no
6454 eval "set -- $ac_configure_args"
6455 for ac_arg
6456 do
6457   if test X"$skip_next" = X"yes"; then
6458     skip_next=no
6459     continue
6460   fi
6461   if test X"$keep_next" = X"yes"; then
6462     case $ac_arg in
6463       *\'*)
6464         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6465     esac
6466     baseargs="$baseargs '$ac_arg'"
6467     keep_next=no
6468     continue
6469   fi
6470
6471   # Handle separated arguments.  Based on the logic generated by
6472   # autoconf 2.59.
6473   case $ac_arg in
6474     *=* | --config-cache | -C | -disable-* | --disable-* \
6475       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6476       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6477       | -with-* | --with-* | -without-* | --without-* | --x)
6478       separate_arg=no
6479       ;;
6480     -*)
6481       separate_arg=yes
6482       ;;
6483     *)
6484       separate_arg=no
6485       ;;
6486   esac
6487
6488   case "$ac_arg" in
6489     --no*)
6490       continue
6491       ;;
6492     --c* | \
6493     --sr* | \
6494     --ho* | \
6495     --bu* | \
6496     --t* | \
6497     --program-* | \
6498     -cache_file* | \
6499     -srcdir* | \
6500     -host* | \
6501     -build* | \
6502     -target* | \
6503     -program-prefix* | \
6504     -program-suffix* | \
6505     -program-transform-name* )
6506       skip_next=$separate_arg
6507       continue
6508       ;;
6509     -*)
6510       # An option.  Add it.
6511       case $ac_arg in
6512         *\'*)
6513           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6514       esac
6515       baseargs="$baseargs '$ac_arg'"
6516       keep_next=$separate_arg
6517       ;;
6518     *)
6519       # Either a variable assignment, or a nonopt (triplet).  Don't
6520       # pass it down; let the Makefile handle this.
6521       continue
6522       ;;
6523   esac
6524 done
6525 # Remove the initial space we just introduced and, as these will be
6526 # expanded by make, quote '$'.
6527 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6528
6529 # Add in --program-transform-name, after --program-prefix and
6530 # --program-suffix have been applied to it.  Autoconf has already
6531 # doubled dollar signs and backslashes in program_transform_name; we want
6532 # the backslashes un-doubled, and then the entire thing wrapped in single
6533 # quotes, because this will be expanded first by make and then by the shell.
6534 # Also, because we want to override the logic in subdir configure scripts to
6535 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6536 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6537 ${program_transform_name}
6538 EOF_SED
6539 gcc_transform_name=`cat conftestsed.out`
6540 rm -f conftestsed.out
6541 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6542 if test "$silent" = yes; then
6543   baseargs="$baseargs --silent"
6544 fi
6545
6546 # For the build-side libraries, we just need to pretend we're native,
6547 # and not use the same cache file.  Multilibs are neither needed nor
6548 # desired.
6549 build_configargs="--cache-file=../config.cache ${baseargs}"
6550
6551 # For host modules, accept cache file option, or specification as blank.
6552 case "${cache_file}" in
6553 "") # empty
6554   cache_file_option="" ;;
6555 /* | [A-Za-z]:[\\/]* ) # absolute path
6556   cache_file_option="--cache-file=${cache_file}" ;;
6557 *) # relative path
6558   cache_file_option="--cache-file=../${cache_file}" ;;
6559 esac
6560
6561 # Host dirs don't like to share a cache file either, horribly enough.
6562 # This seems to be due to autoconf 2.5x stupidity.
6563 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6564
6565 target_configargs=${baseargs}
6566
6567 # Passing a --with-cross-host argument lets the target libraries know
6568 # whether they are being built with a cross-compiler or being built
6569 # native.  However, it would be better to use other mechanisms to make the
6570 # sorts of decisions they want to make on this basis.  Please consider
6571 # this option to be deprecated.  FIXME.
6572 if test x${is_cross_compiler} = xyes ; then
6573   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6574 fi
6575
6576 # Default to --enable-multilib.
6577 if test x${enable_multilib} = x ; then
6578   target_configargs="--enable-multilib ${target_configargs}"
6579 fi
6580
6581 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6582 # changed from the earlier setting of with_newlib.
6583 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6584   target_configargs="--with-newlib ${target_configargs}"
6585 fi
6586
6587 # Different target subdirs use different values of certain variables
6588 # (notably CXX).  Worse, multilibs use *lots* of different values.
6589 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6590 # it doesn't automatically accept command-line overrides of them.
6591 # This means it's not safe for target subdirs to share a cache file,
6592 # which is disgusting, but there you have it.  Hopefully this can be
6593 # fixed in future.  It's still worthwhile to use a cache file for each
6594 # directory.  I think.
6595
6596 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6597 # We need to pass --target, as newer autoconf's requires consistency
6598 # for target_alias and gcc doesn't manage it consistently.
6599 target_configargs="--cache-file=./config.cache ${target_configargs}"
6600
6601 FLAGS_FOR_TARGET=
6602 case " $target_configdirs " in
6603  *" newlib "*)
6604   case " $target_configargs " in
6605   *" --with-newlib "*)
6606    case "$target" in
6607    *-cygwin*)
6608      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup -L$$r/$(TARGET_SUBDIR)/winsup/cygwin -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/include -isystem $$s/winsup/cygwin/include -isystem $$s/winsup/w32api/include' ;;
6609    esac
6610
6611    # If we're not building GCC, don't discard standard headers.
6612    if test -d ${srcdir}/gcc; then
6613      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6614
6615      if test "${build}" != "${host}"; then
6616        # On Canadian crosses, CC_FOR_TARGET will have already been set
6617        # by `configure', so we won't have an opportunity to add -Bgcc/
6618        # to it.  This is right: we don't want to search that directory
6619        # for binaries, but we want the header files in there, so add
6620        # them explicitly.
6621        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6622
6623        # Someone might think of using the pre-installed headers on
6624        # Canadian crosses, in case the installed compiler is not fully
6625        # compatible with the compiler being built.  In this case, it
6626        # would be better to flag an error than risking having
6627        # incompatible object files being constructed.  We can't
6628        # guarantee that an error will be flagged, but let's hope the
6629        # compiler will do it, when presented with incompatible header
6630        # files.
6631      fi
6632    fi
6633
6634    case "${target}-${is_cross_compiler}" in
6635    i[3456789]86-*-linux*-no)
6636       # Here host == target, so we don't need to build gcc,
6637       # so we don't want to discard standard headers.
6638       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6639       ;;
6640    *)
6641       # If we're building newlib, use its generic headers last, but search
6642       # for any libc-related directories first (so make it the last -B
6643       # switch).
6644       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6645
6646       # If we're building libgloss, find the startup file, simulator library
6647       # and linker script.
6648       case " $target_configdirs " in
6649         *" libgloss "*)
6650         # Look for startup file, simulator library and maybe linker script.
6651         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6652         # Look for libnosys.a in case the target needs it.
6653         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6654         # Most targets have the linker script in the source directory.
6655         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6656         ;;
6657       esac
6658       ;;
6659    esac
6660    ;;
6661   esac
6662   ;;
6663 esac
6664 case "$target" in
6665 *-mingw*)
6666   # Can't be handled as Cygwin above since Mingw does not use newlib.
6667   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup/mingw -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/mingw/include -isystem $$s/winsup/w32api/include' ;;
6668 esac
6669
6670 # Allow the user to override the flags for
6671 # our build compiler if desired.
6672 if test x"${build}" = x"${host}" ; then
6673   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6674   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6675   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6676 fi
6677
6678 # On Canadian crosses, we'll be searching the right directories for
6679 # the previously-installed cross compiler, so don't bother to add
6680 # flags for directories within the install tree of the compiler
6681 # being built; programs in there won't even run.
6682 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6683   # Search for pre-installed headers if nothing else fits.
6684   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6685 fi
6686
6687 if test "x${use_gnu_ld}" = x &&
6688    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6689   # Arrange for us to find uninstalled linker scripts.
6690   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6691 fi
6692
6693 # Search for other target-specific linker scripts and such.
6694 case "${target}" in
6695   mep*)
6696     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6697     ;;
6698 esac
6699
6700 # Makefile fragments.
6701 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6702 do
6703   eval fragval=\$$frag
6704   if test $fragval != /dev/null; then
6705     eval $frag=${srcdir}/$fragval
6706   fi
6707 done
6708
6709
6710
6711
6712
6713 # Miscellanea: directories, flags, etc.
6714
6715
6716
6717
6718
6719
6720
6721
6722 # Build module lists & subconfigure args.
6723
6724
6725
6726 # Host module lists & subconfigure args.
6727
6728
6729
6730 # Target module lists & subconfigure args.
6731
6732
6733
6734 # Build tools.
6735
6736
6737
6738
6739
6740
6741
6742
6743
6744
6745
6746
6747
6748
6749
6750
6751
6752 # Generate default definitions for YACC, M4, LEX and other programs that run
6753 # on the build machine.  These are used if the Makefile can't locate these
6754 # programs in objdir.
6755 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6756
6757 for ac_prog in 'bison -y' byacc yacc
6758 do
6759   # Extract the first word of "$ac_prog", so it can be a program name with args.
6760 set dummy $ac_prog; ac_word=$2
6761 echo "$as_me:$LINENO: checking for $ac_word" >&5
6762 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6763 if test "${ac_cv_prog_YACC+set}" = set; then
6764   echo $ECHO_N "(cached) $ECHO_C" >&6
6765 else
6766   if test -n "$YACC"; then
6767   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6768 else
6769 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6770 for as_dir in $PATH
6771 do
6772   IFS=$as_save_IFS
6773   test -z "$as_dir" && as_dir=.
6774   for ac_exec_ext in '' $ac_executable_extensions; do
6775   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6776     ac_cv_prog_YACC="$ac_prog"
6777     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6778     break 2
6779   fi
6780 done
6781 done
6782
6783 fi
6784 fi
6785 YACC=$ac_cv_prog_YACC
6786 if test -n "$YACC"; then
6787   echo "$as_me:$LINENO: result: $YACC" >&5
6788 echo "${ECHO_T}$YACC" >&6
6789 else
6790   echo "$as_me:$LINENO: result: no" >&5
6791 echo "${ECHO_T}no" >&6
6792 fi
6793
6794   test -n "$YACC" && break
6795 done
6796 test -n "$YACC" || YACC="$MISSING bison -y"
6797
6798 case " $build_configdirs " in
6799   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6800   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6801 esac
6802
6803 for ac_prog in bison
6804 do
6805   # Extract the first word of "$ac_prog", so it can be a program name with args.
6806 set dummy $ac_prog; ac_word=$2
6807 echo "$as_me:$LINENO: checking for $ac_word" >&5
6808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6809 if test "${ac_cv_prog_BISON+set}" = set; then
6810   echo $ECHO_N "(cached) $ECHO_C" >&6
6811 else
6812   if test -n "$BISON"; then
6813   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6814 else
6815 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6816 for as_dir in $PATH
6817 do
6818   IFS=$as_save_IFS
6819   test -z "$as_dir" && as_dir=.
6820   for ac_exec_ext in '' $ac_executable_extensions; do
6821   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6822     ac_cv_prog_BISON="$ac_prog"
6823     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6824     break 2
6825   fi
6826 done
6827 done
6828
6829 fi
6830 fi
6831 BISON=$ac_cv_prog_BISON
6832 if test -n "$BISON"; then
6833   echo "$as_me:$LINENO: result: $BISON" >&5
6834 echo "${ECHO_T}$BISON" >&6
6835 else
6836   echo "$as_me:$LINENO: result: no" >&5
6837 echo "${ECHO_T}no" >&6
6838 fi
6839
6840   test -n "$BISON" && break
6841 done
6842 test -n "$BISON" || BISON="$MISSING bison"
6843
6844 case " $build_configdirs " in
6845   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6846 esac
6847
6848 for ac_prog in gm4 gnum4 m4
6849 do
6850   # Extract the first word of "$ac_prog", so it can be a program name with args.
6851 set dummy $ac_prog; ac_word=$2
6852 echo "$as_me:$LINENO: checking for $ac_word" >&5
6853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6854 if test "${ac_cv_prog_M4+set}" = set; then
6855   echo $ECHO_N "(cached) $ECHO_C" >&6
6856 else
6857   if test -n "$M4"; then
6858   ac_cv_prog_M4="$M4" # Let the user override the test.
6859 else
6860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6861 for as_dir in $PATH
6862 do
6863   IFS=$as_save_IFS
6864   test -z "$as_dir" && as_dir=.
6865   for ac_exec_ext in '' $ac_executable_extensions; do
6866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6867     ac_cv_prog_M4="$ac_prog"
6868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6869     break 2
6870   fi
6871 done
6872 done
6873
6874 fi
6875 fi
6876 M4=$ac_cv_prog_M4
6877 if test -n "$M4"; then
6878   echo "$as_me:$LINENO: result: $M4" >&5
6879 echo "${ECHO_T}$M4" >&6
6880 else
6881   echo "$as_me:$LINENO: result: no" >&5
6882 echo "${ECHO_T}no" >&6
6883 fi
6884
6885   test -n "$M4" && break
6886 done
6887 test -n "$M4" || M4="$MISSING m4"
6888
6889 case " $build_configdirs " in
6890   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6891 esac
6892
6893 for ac_prog in flex lex
6894 do
6895   # Extract the first word of "$ac_prog", so it can be a program name with args.
6896 set dummy $ac_prog; ac_word=$2
6897 echo "$as_me:$LINENO: checking for $ac_word" >&5
6898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6899 if test "${ac_cv_prog_LEX+set}" = set; then
6900   echo $ECHO_N "(cached) $ECHO_C" >&6
6901 else
6902   if test -n "$LEX"; then
6903   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6904 else
6905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6906 for as_dir in $PATH
6907 do
6908   IFS=$as_save_IFS
6909   test -z "$as_dir" && as_dir=.
6910   for ac_exec_ext in '' $ac_executable_extensions; do
6911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6912     ac_cv_prog_LEX="$ac_prog"
6913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6914     break 2
6915   fi
6916 done
6917 done
6918
6919 fi
6920 fi
6921 LEX=$ac_cv_prog_LEX
6922 if test -n "$LEX"; then
6923   echo "$as_me:$LINENO: result: $LEX" >&5
6924 echo "${ECHO_T}$LEX" >&6
6925 else
6926   echo "$as_me:$LINENO: result: no" >&5
6927 echo "${ECHO_T}no" >&6
6928 fi
6929
6930   test -n "$LEX" && break
6931 done
6932 test -n "$LEX" || LEX="$MISSING flex"
6933
6934 case " $build_configdirs " in
6935   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6936   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6937 esac
6938
6939 for ac_prog in flex
6940 do
6941   # Extract the first word of "$ac_prog", so it can be a program name with args.
6942 set dummy $ac_prog; ac_word=$2
6943 echo "$as_me:$LINENO: checking for $ac_word" >&5
6944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6945 if test "${ac_cv_prog_FLEX+set}" = set; then
6946   echo $ECHO_N "(cached) $ECHO_C" >&6
6947 else
6948   if test -n "$FLEX"; then
6949   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6950 else
6951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6952 for as_dir in $PATH
6953 do
6954   IFS=$as_save_IFS
6955   test -z "$as_dir" && as_dir=.
6956   for ac_exec_ext in '' $ac_executable_extensions; do
6957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6958     ac_cv_prog_FLEX="$ac_prog"
6959     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6960     break 2
6961   fi
6962 done
6963 done
6964
6965 fi
6966 fi
6967 FLEX=$ac_cv_prog_FLEX
6968 if test -n "$FLEX"; then
6969   echo "$as_me:$LINENO: result: $FLEX" >&5
6970 echo "${ECHO_T}$FLEX" >&6
6971 else
6972   echo "$as_me:$LINENO: result: no" >&5
6973 echo "${ECHO_T}no" >&6
6974 fi
6975
6976   test -n "$FLEX" && break
6977 done
6978 test -n "$FLEX" || FLEX="$MISSING flex"
6979
6980 case " $build_configdirs " in
6981   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6982 esac
6983
6984 for ac_prog in makeinfo
6985 do
6986   # Extract the first word of "$ac_prog", so it can be a program name with args.
6987 set dummy $ac_prog; ac_word=$2
6988 echo "$as_me:$LINENO: checking for $ac_word" >&5
6989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6990 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6991   echo $ECHO_N "(cached) $ECHO_C" >&6
6992 else
6993   if test -n "$MAKEINFO"; then
6994   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6995 else
6996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6997 for as_dir in $PATH
6998 do
6999   IFS=$as_save_IFS
7000   test -z "$as_dir" && as_dir=.
7001   for ac_exec_ext in '' $ac_executable_extensions; do
7002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7003     ac_cv_prog_MAKEINFO="$ac_prog"
7004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7005     break 2
7006   fi
7007 done
7008 done
7009
7010 fi
7011 fi
7012 MAKEINFO=$ac_cv_prog_MAKEINFO
7013 if test -n "$MAKEINFO"; then
7014   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
7015 echo "${ECHO_T}$MAKEINFO" >&6
7016 else
7017   echo "$as_me:$LINENO: result: no" >&5
7018 echo "${ECHO_T}no" >&6
7019 fi
7020
7021   test -n "$MAKEINFO" && break
7022 done
7023 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
7024
7025 case " $build_configdirs " in
7026   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
7027   *)
7028
7029     # For an installed makeinfo, we require it to be from texinfo 4.7 or
7030     # higher, else we use the "missing" dummy.
7031     if ${MAKEINFO} --version \
7032        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
7033       :
7034     else
7035       MAKEINFO="$MISSING makeinfo"
7036     fi
7037     ;;
7038
7039 esac
7040
7041 # FIXME: expect and dejagnu may become build tools?
7042
7043 for ac_prog in expect
7044 do
7045   # Extract the first word of "$ac_prog", so it can be a program name with args.
7046 set dummy $ac_prog; ac_word=$2
7047 echo "$as_me:$LINENO: checking for $ac_word" >&5
7048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7049 if test "${ac_cv_prog_EXPECT+set}" = set; then
7050   echo $ECHO_N "(cached) $ECHO_C" >&6
7051 else
7052   if test -n "$EXPECT"; then
7053   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
7054 else
7055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7056 for as_dir in $PATH
7057 do
7058   IFS=$as_save_IFS
7059   test -z "$as_dir" && as_dir=.
7060   for ac_exec_ext in '' $ac_executable_extensions; do
7061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7062     ac_cv_prog_EXPECT="$ac_prog"
7063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7064     break 2
7065   fi
7066 done
7067 done
7068
7069 fi
7070 fi
7071 EXPECT=$ac_cv_prog_EXPECT
7072 if test -n "$EXPECT"; then
7073   echo "$as_me:$LINENO: result: $EXPECT" >&5
7074 echo "${ECHO_T}$EXPECT" >&6
7075 else
7076   echo "$as_me:$LINENO: result: no" >&5
7077 echo "${ECHO_T}no" >&6
7078 fi
7079
7080   test -n "$EXPECT" && break
7081 done
7082 test -n "$EXPECT" || EXPECT="expect"
7083
7084 case " $configdirs " in
7085   *" expect "*)
7086     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
7087     ;;
7088 esac
7089
7090 for ac_prog in runtest
7091 do
7092   # Extract the first word of "$ac_prog", so it can be a program name with args.
7093 set dummy $ac_prog; ac_word=$2
7094 echo "$as_me:$LINENO: checking for $ac_word" >&5
7095 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7096 if test "${ac_cv_prog_RUNTEST+set}" = set; then
7097   echo $ECHO_N "(cached) $ECHO_C" >&6
7098 else
7099   if test -n "$RUNTEST"; then
7100   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
7101 else
7102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7103 for as_dir in $PATH
7104 do
7105   IFS=$as_save_IFS
7106   test -z "$as_dir" && as_dir=.
7107   for ac_exec_ext in '' $ac_executable_extensions; do
7108   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7109     ac_cv_prog_RUNTEST="$ac_prog"
7110     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7111     break 2
7112   fi
7113 done
7114 done
7115
7116 fi
7117 fi
7118 RUNTEST=$ac_cv_prog_RUNTEST
7119 if test -n "$RUNTEST"; then
7120   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7121 echo "${ECHO_T}$RUNTEST" >&6
7122 else
7123   echo "$as_me:$LINENO: result: no" >&5
7124 echo "${ECHO_T}no" >&6
7125 fi
7126
7127   test -n "$RUNTEST" && break
7128 done
7129 test -n "$RUNTEST" || RUNTEST="runtest"
7130
7131 case " $configdirs " in
7132   *" dejagnu "*)
7133     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7134     ;;
7135 esac
7136
7137
7138 # Host tools.
7139 ncn_tool_prefix=
7140 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7141 ncn_target_tool_prefix=
7142 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7143
7144
7145
7146 if test -n "$AR"; then
7147   ac_cv_prog_AR=$AR
7148 elif test -n "$ac_cv_prog_AR"; then
7149   AR=$ac_cv_prog_AR
7150 fi
7151
7152 if test -n "$ac_cv_prog_AR"; then
7153   for ncn_progname in ar; do
7154     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7155 set dummy ${ncn_progname}; ac_word=$2
7156 echo "$as_me:$LINENO: checking for $ac_word" >&5
7157 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7158 if test "${ac_cv_prog_AR+set}" = set; then
7159   echo $ECHO_N "(cached) $ECHO_C" >&6
7160 else
7161   if test -n "$AR"; then
7162   ac_cv_prog_AR="$AR" # Let the user override the test.
7163 else
7164 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7165 for as_dir in $PATH
7166 do
7167   IFS=$as_save_IFS
7168   test -z "$as_dir" && as_dir=.
7169   for ac_exec_ext in '' $ac_executable_extensions; do
7170   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7171     ac_cv_prog_AR="${ncn_progname}"
7172     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7173     break 2
7174   fi
7175 done
7176 done
7177
7178 fi
7179 fi
7180 AR=$ac_cv_prog_AR
7181 if test -n "$AR"; then
7182   echo "$as_me:$LINENO: result: $AR" >&5
7183 echo "${ECHO_T}$AR" >&6
7184 else
7185   echo "$as_me:$LINENO: result: no" >&5
7186 echo "${ECHO_T}no" >&6
7187 fi
7188
7189   done
7190 fi
7191
7192 for ncn_progname in ar; do
7193   if test -n "$ncn_tool_prefix"; then
7194     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7195 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7196 echo "$as_me:$LINENO: checking for $ac_word" >&5
7197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7198 if test "${ac_cv_prog_AR+set}" = set; then
7199   echo $ECHO_N "(cached) $ECHO_C" >&6
7200 else
7201   if test -n "$AR"; then
7202   ac_cv_prog_AR="$AR" # Let the user override the test.
7203 else
7204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7205 for as_dir in $PATH
7206 do
7207   IFS=$as_save_IFS
7208   test -z "$as_dir" && as_dir=.
7209   for ac_exec_ext in '' $ac_executable_extensions; do
7210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7211     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7213     break 2
7214   fi
7215 done
7216 done
7217
7218 fi
7219 fi
7220 AR=$ac_cv_prog_AR
7221 if test -n "$AR"; then
7222   echo "$as_me:$LINENO: result: $AR" >&5
7223 echo "${ECHO_T}$AR" >&6
7224 else
7225   echo "$as_me:$LINENO: result: no" >&5
7226 echo "${ECHO_T}no" >&6
7227 fi
7228
7229   fi
7230   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7231     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7232 set dummy ${ncn_progname}; ac_word=$2
7233 echo "$as_me:$LINENO: checking for $ac_word" >&5
7234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7235 if test "${ac_cv_prog_AR+set}" = set; then
7236   echo $ECHO_N "(cached) $ECHO_C" >&6
7237 else
7238   if test -n "$AR"; then
7239   ac_cv_prog_AR="$AR" # Let the user override the test.
7240 else
7241 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7242 for as_dir in $PATH
7243 do
7244   IFS=$as_save_IFS
7245   test -z "$as_dir" && as_dir=.
7246   for ac_exec_ext in '' $ac_executable_extensions; do
7247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7248     ac_cv_prog_AR="${ncn_progname}"
7249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7250     break 2
7251   fi
7252 done
7253 done
7254
7255 fi
7256 fi
7257 AR=$ac_cv_prog_AR
7258 if test -n "$AR"; then
7259   echo "$as_me:$LINENO: result: $AR" >&5
7260 echo "${ECHO_T}$AR" >&6
7261 else
7262   echo "$as_me:$LINENO: result: no" >&5
7263 echo "${ECHO_T}no" >&6
7264 fi
7265
7266   fi
7267   test -n "$ac_cv_prog_AR" && break
7268 done
7269
7270 if test -z "$ac_cv_prog_AR" ; then
7271   set dummy ar
7272   if test $build = $host ; then
7273     AR="$2"
7274   else
7275     AR="${ncn_tool_prefix}$2"
7276   fi
7277 fi
7278
7279
7280
7281 if test -n "$AS"; then
7282   ac_cv_prog_AS=$AS
7283 elif test -n "$ac_cv_prog_AS"; then
7284   AS=$ac_cv_prog_AS
7285 fi
7286
7287 if test -n "$ac_cv_prog_AS"; then
7288   for ncn_progname in as; do
7289     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7290 set dummy ${ncn_progname}; ac_word=$2
7291 echo "$as_me:$LINENO: checking for $ac_word" >&5
7292 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7293 if test "${ac_cv_prog_AS+set}" = set; then
7294   echo $ECHO_N "(cached) $ECHO_C" >&6
7295 else
7296   if test -n "$AS"; then
7297   ac_cv_prog_AS="$AS" # Let the user override the test.
7298 else
7299 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7300 for as_dir in $PATH
7301 do
7302   IFS=$as_save_IFS
7303   test -z "$as_dir" && as_dir=.
7304   for ac_exec_ext in '' $ac_executable_extensions; do
7305   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7306     ac_cv_prog_AS="${ncn_progname}"
7307     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7308     break 2
7309   fi
7310 done
7311 done
7312
7313 fi
7314 fi
7315 AS=$ac_cv_prog_AS
7316 if test -n "$AS"; then
7317   echo "$as_me:$LINENO: result: $AS" >&5
7318 echo "${ECHO_T}$AS" >&6
7319 else
7320   echo "$as_me:$LINENO: result: no" >&5
7321 echo "${ECHO_T}no" >&6
7322 fi
7323
7324   done
7325 fi
7326
7327 for ncn_progname in as; do
7328   if test -n "$ncn_tool_prefix"; then
7329     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7330 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7331 echo "$as_me:$LINENO: checking for $ac_word" >&5
7332 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7333 if test "${ac_cv_prog_AS+set}" = set; then
7334   echo $ECHO_N "(cached) $ECHO_C" >&6
7335 else
7336   if test -n "$AS"; then
7337   ac_cv_prog_AS="$AS" # Let the user override the test.
7338 else
7339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7340 for as_dir in $PATH
7341 do
7342   IFS=$as_save_IFS
7343   test -z "$as_dir" && as_dir=.
7344   for ac_exec_ext in '' $ac_executable_extensions; do
7345   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7346     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7347     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7348     break 2
7349   fi
7350 done
7351 done
7352
7353 fi
7354 fi
7355 AS=$ac_cv_prog_AS
7356 if test -n "$AS"; then
7357   echo "$as_me:$LINENO: result: $AS" >&5
7358 echo "${ECHO_T}$AS" >&6
7359 else
7360   echo "$as_me:$LINENO: result: no" >&5
7361 echo "${ECHO_T}no" >&6
7362 fi
7363
7364   fi
7365   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7366     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7367 set dummy ${ncn_progname}; ac_word=$2
7368 echo "$as_me:$LINENO: checking for $ac_word" >&5
7369 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7370 if test "${ac_cv_prog_AS+set}" = set; then
7371   echo $ECHO_N "(cached) $ECHO_C" >&6
7372 else
7373   if test -n "$AS"; then
7374   ac_cv_prog_AS="$AS" # Let the user override the test.
7375 else
7376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7377 for as_dir in $PATH
7378 do
7379   IFS=$as_save_IFS
7380   test -z "$as_dir" && as_dir=.
7381   for ac_exec_ext in '' $ac_executable_extensions; do
7382   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7383     ac_cv_prog_AS="${ncn_progname}"
7384     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7385     break 2
7386   fi
7387 done
7388 done
7389
7390 fi
7391 fi
7392 AS=$ac_cv_prog_AS
7393 if test -n "$AS"; then
7394   echo "$as_me:$LINENO: result: $AS" >&5
7395 echo "${ECHO_T}$AS" >&6
7396 else
7397   echo "$as_me:$LINENO: result: no" >&5
7398 echo "${ECHO_T}no" >&6
7399 fi
7400
7401   fi
7402   test -n "$ac_cv_prog_AS" && break
7403 done
7404
7405 if test -z "$ac_cv_prog_AS" ; then
7406   set dummy as
7407   if test $build = $host ; then
7408     AS="$2"
7409   else
7410     AS="${ncn_tool_prefix}$2"
7411   fi
7412 fi
7413
7414
7415
7416 if test -n "$DLLTOOL"; then
7417   ac_cv_prog_DLLTOOL=$DLLTOOL
7418 elif test -n "$ac_cv_prog_DLLTOOL"; then
7419   DLLTOOL=$ac_cv_prog_DLLTOOL
7420 fi
7421
7422 if test -n "$ac_cv_prog_DLLTOOL"; then
7423   for ncn_progname in dlltool; do
7424     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7425 set dummy ${ncn_progname}; ac_word=$2
7426 echo "$as_me:$LINENO: checking for $ac_word" >&5
7427 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7428 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7429   echo $ECHO_N "(cached) $ECHO_C" >&6
7430 else
7431   if test -n "$DLLTOOL"; then
7432   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7433 else
7434 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7435 for as_dir in $PATH
7436 do
7437   IFS=$as_save_IFS
7438   test -z "$as_dir" && as_dir=.
7439   for ac_exec_ext in '' $ac_executable_extensions; do
7440   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7441     ac_cv_prog_DLLTOOL="${ncn_progname}"
7442     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7443     break 2
7444   fi
7445 done
7446 done
7447
7448 fi
7449 fi
7450 DLLTOOL=$ac_cv_prog_DLLTOOL
7451 if test -n "$DLLTOOL"; then
7452   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7453 echo "${ECHO_T}$DLLTOOL" >&6
7454 else
7455   echo "$as_me:$LINENO: result: no" >&5
7456 echo "${ECHO_T}no" >&6
7457 fi
7458
7459   done
7460 fi
7461
7462 for ncn_progname in dlltool; do
7463   if test -n "$ncn_tool_prefix"; then
7464     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7465 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7466 echo "$as_me:$LINENO: checking for $ac_word" >&5
7467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7468 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7469   echo $ECHO_N "(cached) $ECHO_C" >&6
7470 else
7471   if test -n "$DLLTOOL"; then
7472   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7473 else
7474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7475 for as_dir in $PATH
7476 do
7477   IFS=$as_save_IFS
7478   test -z "$as_dir" && as_dir=.
7479   for ac_exec_ext in '' $ac_executable_extensions; do
7480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7481     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7483     break 2
7484   fi
7485 done
7486 done
7487
7488 fi
7489 fi
7490 DLLTOOL=$ac_cv_prog_DLLTOOL
7491 if test -n "$DLLTOOL"; then
7492   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7493 echo "${ECHO_T}$DLLTOOL" >&6
7494 else
7495   echo "$as_me:$LINENO: result: no" >&5
7496 echo "${ECHO_T}no" >&6
7497 fi
7498
7499   fi
7500   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7501     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7502 set dummy ${ncn_progname}; ac_word=$2
7503 echo "$as_me:$LINENO: checking for $ac_word" >&5
7504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7505 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7506   echo $ECHO_N "(cached) $ECHO_C" >&6
7507 else
7508   if test -n "$DLLTOOL"; then
7509   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7510 else
7511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7512 for as_dir in $PATH
7513 do
7514   IFS=$as_save_IFS
7515   test -z "$as_dir" && as_dir=.
7516   for ac_exec_ext in '' $ac_executable_extensions; do
7517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7518     ac_cv_prog_DLLTOOL="${ncn_progname}"
7519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7520     break 2
7521   fi
7522 done
7523 done
7524
7525 fi
7526 fi
7527 DLLTOOL=$ac_cv_prog_DLLTOOL
7528 if test -n "$DLLTOOL"; then
7529   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7530 echo "${ECHO_T}$DLLTOOL" >&6
7531 else
7532   echo "$as_me:$LINENO: result: no" >&5
7533 echo "${ECHO_T}no" >&6
7534 fi
7535
7536   fi
7537   test -n "$ac_cv_prog_DLLTOOL" && break
7538 done
7539
7540 if test -z "$ac_cv_prog_DLLTOOL" ; then
7541   set dummy dlltool
7542   if test $build = $host ; then
7543     DLLTOOL="$2"
7544   else
7545     DLLTOOL="${ncn_tool_prefix}$2"
7546   fi
7547 fi
7548
7549
7550
7551 if test -n "$LD"; then
7552   ac_cv_prog_LD=$LD
7553 elif test -n "$ac_cv_prog_LD"; then
7554   LD=$ac_cv_prog_LD
7555 fi
7556
7557 if test -n "$ac_cv_prog_LD"; then
7558   for ncn_progname in ld; do
7559     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7560 set dummy ${ncn_progname}; ac_word=$2
7561 echo "$as_me:$LINENO: checking for $ac_word" >&5
7562 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7563 if test "${ac_cv_prog_LD+set}" = set; then
7564   echo $ECHO_N "(cached) $ECHO_C" >&6
7565 else
7566   if test -n "$LD"; then
7567   ac_cv_prog_LD="$LD" # Let the user override the test.
7568 else
7569 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7570 for as_dir in $PATH
7571 do
7572   IFS=$as_save_IFS
7573   test -z "$as_dir" && as_dir=.
7574   for ac_exec_ext in '' $ac_executable_extensions; do
7575   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7576     ac_cv_prog_LD="${ncn_progname}"
7577     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7578     break 2
7579   fi
7580 done
7581 done
7582
7583 fi
7584 fi
7585 LD=$ac_cv_prog_LD
7586 if test -n "$LD"; then
7587   echo "$as_me:$LINENO: result: $LD" >&5
7588 echo "${ECHO_T}$LD" >&6
7589 else
7590   echo "$as_me:$LINENO: result: no" >&5
7591 echo "${ECHO_T}no" >&6
7592 fi
7593
7594   done
7595 fi
7596
7597 for ncn_progname in ld; do
7598   if test -n "$ncn_tool_prefix"; then
7599     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7600 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7601 echo "$as_me:$LINENO: checking for $ac_word" >&5
7602 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7603 if test "${ac_cv_prog_LD+set}" = set; then
7604   echo $ECHO_N "(cached) $ECHO_C" >&6
7605 else
7606   if test -n "$LD"; then
7607   ac_cv_prog_LD="$LD" # Let the user override the test.
7608 else
7609 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7610 for as_dir in $PATH
7611 do
7612   IFS=$as_save_IFS
7613   test -z "$as_dir" && as_dir=.
7614   for ac_exec_ext in '' $ac_executable_extensions; do
7615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7616     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7618     break 2
7619   fi
7620 done
7621 done
7622
7623 fi
7624 fi
7625 LD=$ac_cv_prog_LD
7626 if test -n "$LD"; then
7627   echo "$as_me:$LINENO: result: $LD" >&5
7628 echo "${ECHO_T}$LD" >&6
7629 else
7630   echo "$as_me:$LINENO: result: no" >&5
7631 echo "${ECHO_T}no" >&6
7632 fi
7633
7634   fi
7635   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7636     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7637 set dummy ${ncn_progname}; ac_word=$2
7638 echo "$as_me:$LINENO: checking for $ac_word" >&5
7639 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7640 if test "${ac_cv_prog_LD+set}" = set; then
7641   echo $ECHO_N "(cached) $ECHO_C" >&6
7642 else
7643   if test -n "$LD"; then
7644   ac_cv_prog_LD="$LD" # Let the user override the test.
7645 else
7646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7647 for as_dir in $PATH
7648 do
7649   IFS=$as_save_IFS
7650   test -z "$as_dir" && as_dir=.
7651   for ac_exec_ext in '' $ac_executable_extensions; do
7652   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7653     ac_cv_prog_LD="${ncn_progname}"
7654     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7655     break 2
7656   fi
7657 done
7658 done
7659
7660 fi
7661 fi
7662 LD=$ac_cv_prog_LD
7663 if test -n "$LD"; then
7664   echo "$as_me:$LINENO: result: $LD" >&5
7665 echo "${ECHO_T}$LD" >&6
7666 else
7667   echo "$as_me:$LINENO: result: no" >&5
7668 echo "${ECHO_T}no" >&6
7669 fi
7670
7671   fi
7672   test -n "$ac_cv_prog_LD" && break
7673 done
7674
7675 if test -z "$ac_cv_prog_LD" ; then
7676   set dummy ld
7677   if test $build = $host ; then
7678     LD="$2"
7679   else
7680     LD="${ncn_tool_prefix}$2"
7681   fi
7682 fi
7683
7684
7685
7686 if test -n "$LIPO"; then
7687   ac_cv_prog_LIPO=$LIPO
7688 elif test -n "$ac_cv_prog_LIPO"; then
7689   LIPO=$ac_cv_prog_LIPO
7690 fi
7691
7692 if test -n "$ac_cv_prog_LIPO"; then
7693   for ncn_progname in lipo; do
7694     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7695 set dummy ${ncn_progname}; ac_word=$2
7696 echo "$as_me:$LINENO: checking for $ac_word" >&5
7697 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7698 if test "${ac_cv_prog_LIPO+set}" = set; then
7699   echo $ECHO_N "(cached) $ECHO_C" >&6
7700 else
7701   if test -n "$LIPO"; then
7702   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7703 else
7704 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7705 for as_dir in $PATH
7706 do
7707   IFS=$as_save_IFS
7708   test -z "$as_dir" && as_dir=.
7709   for ac_exec_ext in '' $ac_executable_extensions; do
7710   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7711     ac_cv_prog_LIPO="${ncn_progname}"
7712     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7713     break 2
7714   fi
7715 done
7716 done
7717
7718 fi
7719 fi
7720 LIPO=$ac_cv_prog_LIPO
7721 if test -n "$LIPO"; then
7722   echo "$as_me:$LINENO: result: $LIPO" >&5
7723 echo "${ECHO_T}$LIPO" >&6
7724 else
7725   echo "$as_me:$LINENO: result: no" >&5
7726 echo "${ECHO_T}no" >&6
7727 fi
7728
7729   done
7730 fi
7731
7732 for ncn_progname in lipo; do
7733   if test -n "$ncn_tool_prefix"; then
7734     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7735 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7736 echo "$as_me:$LINENO: checking for $ac_word" >&5
7737 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7738 if test "${ac_cv_prog_LIPO+set}" = set; then
7739   echo $ECHO_N "(cached) $ECHO_C" >&6
7740 else
7741   if test -n "$LIPO"; then
7742   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7743 else
7744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7745 for as_dir in $PATH
7746 do
7747   IFS=$as_save_IFS
7748   test -z "$as_dir" && as_dir=.
7749   for ac_exec_ext in '' $ac_executable_extensions; do
7750   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7751     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7752     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7753     break 2
7754   fi
7755 done
7756 done
7757
7758 fi
7759 fi
7760 LIPO=$ac_cv_prog_LIPO
7761 if test -n "$LIPO"; then
7762   echo "$as_me:$LINENO: result: $LIPO" >&5
7763 echo "${ECHO_T}$LIPO" >&6
7764 else
7765   echo "$as_me:$LINENO: result: no" >&5
7766 echo "${ECHO_T}no" >&6
7767 fi
7768
7769   fi
7770   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7771     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7772 set dummy ${ncn_progname}; ac_word=$2
7773 echo "$as_me:$LINENO: checking for $ac_word" >&5
7774 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7775 if test "${ac_cv_prog_LIPO+set}" = set; then
7776   echo $ECHO_N "(cached) $ECHO_C" >&6
7777 else
7778   if test -n "$LIPO"; then
7779   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7780 else
7781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7782 for as_dir in $PATH
7783 do
7784   IFS=$as_save_IFS
7785   test -z "$as_dir" && as_dir=.
7786   for ac_exec_ext in '' $ac_executable_extensions; do
7787   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7788     ac_cv_prog_LIPO="${ncn_progname}"
7789     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7790     break 2
7791   fi
7792 done
7793 done
7794
7795 fi
7796 fi
7797 LIPO=$ac_cv_prog_LIPO
7798 if test -n "$LIPO"; then
7799   echo "$as_me:$LINENO: result: $LIPO" >&5
7800 echo "${ECHO_T}$LIPO" >&6
7801 else
7802   echo "$as_me:$LINENO: result: no" >&5
7803 echo "${ECHO_T}no" >&6
7804 fi
7805
7806   fi
7807   test -n "$ac_cv_prog_LIPO" && break
7808 done
7809
7810 if test -z "$ac_cv_prog_LIPO" ; then
7811   set dummy lipo
7812   if test $build = $host ; then
7813     LIPO="$2"
7814   else
7815     LIPO="${ncn_tool_prefix}$2"
7816   fi
7817 fi
7818
7819
7820
7821 if test -n "$NM"; then
7822   ac_cv_prog_NM=$NM
7823 elif test -n "$ac_cv_prog_NM"; then
7824   NM=$ac_cv_prog_NM
7825 fi
7826
7827 if test -n "$ac_cv_prog_NM"; then
7828   for ncn_progname in nm; do
7829     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7830 set dummy ${ncn_progname}; ac_word=$2
7831 echo "$as_me:$LINENO: checking for $ac_word" >&5
7832 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7833 if test "${ac_cv_prog_NM+set}" = set; then
7834   echo $ECHO_N "(cached) $ECHO_C" >&6
7835 else
7836   if test -n "$NM"; then
7837   ac_cv_prog_NM="$NM" # Let the user override the test.
7838 else
7839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7840 for as_dir in $PATH
7841 do
7842   IFS=$as_save_IFS
7843   test -z "$as_dir" && as_dir=.
7844   for ac_exec_ext in '' $ac_executable_extensions; do
7845   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7846     ac_cv_prog_NM="${ncn_progname}"
7847     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7848     break 2
7849   fi
7850 done
7851 done
7852
7853 fi
7854 fi
7855 NM=$ac_cv_prog_NM
7856 if test -n "$NM"; then
7857   echo "$as_me:$LINENO: result: $NM" >&5
7858 echo "${ECHO_T}$NM" >&6
7859 else
7860   echo "$as_me:$LINENO: result: no" >&5
7861 echo "${ECHO_T}no" >&6
7862 fi
7863
7864   done
7865 fi
7866
7867 for ncn_progname in nm; do
7868   if test -n "$ncn_tool_prefix"; then
7869     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7870 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7871 echo "$as_me:$LINENO: checking for $ac_word" >&5
7872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7873 if test "${ac_cv_prog_NM+set}" = set; then
7874   echo $ECHO_N "(cached) $ECHO_C" >&6
7875 else
7876   if test -n "$NM"; then
7877   ac_cv_prog_NM="$NM" # Let the user override the test.
7878 else
7879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7880 for as_dir in $PATH
7881 do
7882   IFS=$as_save_IFS
7883   test -z "$as_dir" && as_dir=.
7884   for ac_exec_ext in '' $ac_executable_extensions; do
7885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7886     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7888     break 2
7889   fi
7890 done
7891 done
7892
7893 fi
7894 fi
7895 NM=$ac_cv_prog_NM
7896 if test -n "$NM"; then
7897   echo "$as_me:$LINENO: result: $NM" >&5
7898 echo "${ECHO_T}$NM" >&6
7899 else
7900   echo "$as_me:$LINENO: result: no" >&5
7901 echo "${ECHO_T}no" >&6
7902 fi
7903
7904   fi
7905   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7906     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7907 set dummy ${ncn_progname}; ac_word=$2
7908 echo "$as_me:$LINENO: checking for $ac_word" >&5
7909 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7910 if test "${ac_cv_prog_NM+set}" = set; then
7911   echo $ECHO_N "(cached) $ECHO_C" >&6
7912 else
7913   if test -n "$NM"; then
7914   ac_cv_prog_NM="$NM" # Let the user override the test.
7915 else
7916 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7917 for as_dir in $PATH
7918 do
7919   IFS=$as_save_IFS
7920   test -z "$as_dir" && as_dir=.
7921   for ac_exec_ext in '' $ac_executable_extensions; do
7922   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7923     ac_cv_prog_NM="${ncn_progname}"
7924     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7925     break 2
7926   fi
7927 done
7928 done
7929
7930 fi
7931 fi
7932 NM=$ac_cv_prog_NM
7933 if test -n "$NM"; then
7934   echo "$as_me:$LINENO: result: $NM" >&5
7935 echo "${ECHO_T}$NM" >&6
7936 else
7937   echo "$as_me:$LINENO: result: no" >&5
7938 echo "${ECHO_T}no" >&6
7939 fi
7940
7941   fi
7942   test -n "$ac_cv_prog_NM" && break
7943 done
7944
7945 if test -z "$ac_cv_prog_NM" ; then
7946   set dummy nm
7947   if test $build = $host ; then
7948     NM="$2"
7949   else
7950     NM="${ncn_tool_prefix}$2"
7951   fi
7952 fi
7953
7954
7955
7956 if test -n "$RANLIB"; then
7957   ac_cv_prog_RANLIB=$RANLIB
7958 elif test -n "$ac_cv_prog_RANLIB"; then
7959   RANLIB=$ac_cv_prog_RANLIB
7960 fi
7961
7962 if test -n "$ac_cv_prog_RANLIB"; then
7963   for ncn_progname in ranlib; do
7964     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7965 set dummy ${ncn_progname}; ac_word=$2
7966 echo "$as_me:$LINENO: checking for $ac_word" >&5
7967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7968 if test "${ac_cv_prog_RANLIB+set}" = set; then
7969   echo $ECHO_N "(cached) $ECHO_C" >&6
7970 else
7971   if test -n "$RANLIB"; then
7972   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7973 else
7974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7975 for as_dir in $PATH
7976 do
7977   IFS=$as_save_IFS
7978   test -z "$as_dir" && as_dir=.
7979   for ac_exec_ext in '' $ac_executable_extensions; do
7980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7981     ac_cv_prog_RANLIB="${ncn_progname}"
7982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7983     break 2
7984   fi
7985 done
7986 done
7987
7988 fi
7989 fi
7990 RANLIB=$ac_cv_prog_RANLIB
7991 if test -n "$RANLIB"; then
7992   echo "$as_me:$LINENO: result: $RANLIB" >&5
7993 echo "${ECHO_T}$RANLIB" >&6
7994 else
7995   echo "$as_me:$LINENO: result: no" >&5
7996 echo "${ECHO_T}no" >&6
7997 fi
7998
7999   done
8000 fi
8001
8002 for ncn_progname in ranlib; do
8003   if test -n "$ncn_tool_prefix"; then
8004     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8005 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8006 echo "$as_me:$LINENO: checking for $ac_word" >&5
8007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8008 if test "${ac_cv_prog_RANLIB+set}" = set; then
8009   echo $ECHO_N "(cached) $ECHO_C" >&6
8010 else
8011   if test -n "$RANLIB"; then
8012   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8013 else
8014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8015 for as_dir in $PATH
8016 do
8017   IFS=$as_save_IFS
8018   test -z "$as_dir" && as_dir=.
8019   for ac_exec_ext in '' $ac_executable_extensions; do
8020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8021     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
8022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8023     break 2
8024   fi
8025 done
8026 done
8027
8028 fi
8029 fi
8030 RANLIB=$ac_cv_prog_RANLIB
8031 if test -n "$RANLIB"; then
8032   echo "$as_me:$LINENO: result: $RANLIB" >&5
8033 echo "${ECHO_T}$RANLIB" >&6
8034 else
8035   echo "$as_me:$LINENO: result: no" >&5
8036 echo "${ECHO_T}no" >&6
8037 fi
8038
8039   fi
8040   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
8041     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8042 set dummy ${ncn_progname}; ac_word=$2
8043 echo "$as_me:$LINENO: checking for $ac_word" >&5
8044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8045 if test "${ac_cv_prog_RANLIB+set}" = set; then
8046   echo $ECHO_N "(cached) $ECHO_C" >&6
8047 else
8048   if test -n "$RANLIB"; then
8049   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
8050 else
8051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8052 for as_dir in $PATH
8053 do
8054   IFS=$as_save_IFS
8055   test -z "$as_dir" && as_dir=.
8056   for ac_exec_ext in '' $ac_executable_extensions; do
8057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8058     ac_cv_prog_RANLIB="${ncn_progname}"
8059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8060     break 2
8061   fi
8062 done
8063 done
8064
8065 fi
8066 fi
8067 RANLIB=$ac_cv_prog_RANLIB
8068 if test -n "$RANLIB"; then
8069   echo "$as_me:$LINENO: result: $RANLIB" >&5
8070 echo "${ECHO_T}$RANLIB" >&6
8071 else
8072   echo "$as_me:$LINENO: result: no" >&5
8073 echo "${ECHO_T}no" >&6
8074 fi
8075
8076   fi
8077   test -n "$ac_cv_prog_RANLIB" && break
8078 done
8079
8080 if test -z "$ac_cv_prog_RANLIB" ; then
8081   RANLIB=":"
8082 fi
8083
8084
8085
8086 if test -n "$STRIP"; then
8087   ac_cv_prog_STRIP=$STRIP
8088 elif test -n "$ac_cv_prog_STRIP"; then
8089   STRIP=$ac_cv_prog_STRIP
8090 fi
8091
8092 if test -n "$ac_cv_prog_STRIP"; then
8093   for ncn_progname in strip; do
8094     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8095 set dummy ${ncn_progname}; ac_word=$2
8096 echo "$as_me:$LINENO: checking for $ac_word" >&5
8097 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8098 if test "${ac_cv_prog_STRIP+set}" = set; then
8099   echo $ECHO_N "(cached) $ECHO_C" >&6
8100 else
8101   if test -n "$STRIP"; then
8102   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8103 else
8104 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8105 for as_dir in $PATH
8106 do
8107   IFS=$as_save_IFS
8108   test -z "$as_dir" && as_dir=.
8109   for ac_exec_ext in '' $ac_executable_extensions; do
8110   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8111     ac_cv_prog_STRIP="${ncn_progname}"
8112     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8113     break 2
8114   fi
8115 done
8116 done
8117
8118 fi
8119 fi
8120 STRIP=$ac_cv_prog_STRIP
8121 if test -n "$STRIP"; then
8122   echo "$as_me:$LINENO: result: $STRIP" >&5
8123 echo "${ECHO_T}$STRIP" >&6
8124 else
8125   echo "$as_me:$LINENO: result: no" >&5
8126 echo "${ECHO_T}no" >&6
8127 fi
8128
8129   done
8130 fi
8131
8132 for ncn_progname in strip; do
8133   if test -n "$ncn_tool_prefix"; then
8134     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8135 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8136 echo "$as_me:$LINENO: checking for $ac_word" >&5
8137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8138 if test "${ac_cv_prog_STRIP+set}" = set; then
8139   echo $ECHO_N "(cached) $ECHO_C" >&6
8140 else
8141   if test -n "$STRIP"; then
8142   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8143 else
8144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8145 for as_dir in $PATH
8146 do
8147   IFS=$as_save_IFS
8148   test -z "$as_dir" && as_dir=.
8149   for ac_exec_ext in '' $ac_executable_extensions; do
8150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8151     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8153     break 2
8154   fi
8155 done
8156 done
8157
8158 fi
8159 fi
8160 STRIP=$ac_cv_prog_STRIP
8161 if test -n "$STRIP"; then
8162   echo "$as_me:$LINENO: result: $STRIP" >&5
8163 echo "${ECHO_T}$STRIP" >&6
8164 else
8165   echo "$as_me:$LINENO: result: no" >&5
8166 echo "${ECHO_T}no" >&6
8167 fi
8168
8169   fi
8170   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8171     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8172 set dummy ${ncn_progname}; ac_word=$2
8173 echo "$as_me:$LINENO: checking for $ac_word" >&5
8174 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8175 if test "${ac_cv_prog_STRIP+set}" = set; then
8176   echo $ECHO_N "(cached) $ECHO_C" >&6
8177 else
8178   if test -n "$STRIP"; then
8179   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8180 else
8181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8182 for as_dir in $PATH
8183 do
8184   IFS=$as_save_IFS
8185   test -z "$as_dir" && as_dir=.
8186   for ac_exec_ext in '' $ac_executable_extensions; do
8187   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8188     ac_cv_prog_STRIP="${ncn_progname}"
8189     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8190     break 2
8191   fi
8192 done
8193 done
8194
8195 fi
8196 fi
8197 STRIP=$ac_cv_prog_STRIP
8198 if test -n "$STRIP"; then
8199   echo "$as_me:$LINENO: result: $STRIP" >&5
8200 echo "${ECHO_T}$STRIP" >&6
8201 else
8202   echo "$as_me:$LINENO: result: no" >&5
8203 echo "${ECHO_T}no" >&6
8204 fi
8205
8206   fi
8207   test -n "$ac_cv_prog_STRIP" && break
8208 done
8209
8210 if test -z "$ac_cv_prog_STRIP" ; then
8211   STRIP=":"
8212 fi
8213
8214
8215
8216 if test -n "$WINDRES"; then
8217   ac_cv_prog_WINDRES=$WINDRES
8218 elif test -n "$ac_cv_prog_WINDRES"; then
8219   WINDRES=$ac_cv_prog_WINDRES
8220 fi
8221
8222 if test -n "$ac_cv_prog_WINDRES"; then
8223   for ncn_progname in windres; do
8224     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8225 set dummy ${ncn_progname}; ac_word=$2
8226 echo "$as_me:$LINENO: checking for $ac_word" >&5
8227 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8228 if test "${ac_cv_prog_WINDRES+set}" = set; then
8229   echo $ECHO_N "(cached) $ECHO_C" >&6
8230 else
8231   if test -n "$WINDRES"; then
8232   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8233 else
8234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8235 for as_dir in $PATH
8236 do
8237   IFS=$as_save_IFS
8238   test -z "$as_dir" && as_dir=.
8239   for ac_exec_ext in '' $ac_executable_extensions; do
8240   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8241     ac_cv_prog_WINDRES="${ncn_progname}"
8242     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8243     break 2
8244   fi
8245 done
8246 done
8247
8248 fi
8249 fi
8250 WINDRES=$ac_cv_prog_WINDRES
8251 if test -n "$WINDRES"; then
8252   echo "$as_me:$LINENO: result: $WINDRES" >&5
8253 echo "${ECHO_T}$WINDRES" >&6
8254 else
8255   echo "$as_me:$LINENO: result: no" >&5
8256 echo "${ECHO_T}no" >&6
8257 fi
8258
8259   done
8260 fi
8261
8262 for ncn_progname in windres; do
8263   if test -n "$ncn_tool_prefix"; then
8264     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8265 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8266 echo "$as_me:$LINENO: checking for $ac_word" >&5
8267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8268 if test "${ac_cv_prog_WINDRES+set}" = set; then
8269   echo $ECHO_N "(cached) $ECHO_C" >&6
8270 else
8271   if test -n "$WINDRES"; then
8272   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8273 else
8274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8275 for as_dir in $PATH
8276 do
8277   IFS=$as_save_IFS
8278   test -z "$as_dir" && as_dir=.
8279   for ac_exec_ext in '' $ac_executable_extensions; do
8280   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8281     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8282     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8283     break 2
8284   fi
8285 done
8286 done
8287
8288 fi
8289 fi
8290 WINDRES=$ac_cv_prog_WINDRES
8291 if test -n "$WINDRES"; then
8292   echo "$as_me:$LINENO: result: $WINDRES" >&5
8293 echo "${ECHO_T}$WINDRES" >&6
8294 else
8295   echo "$as_me:$LINENO: result: no" >&5
8296 echo "${ECHO_T}no" >&6
8297 fi
8298
8299   fi
8300   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8301     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8302 set dummy ${ncn_progname}; ac_word=$2
8303 echo "$as_me:$LINENO: checking for $ac_word" >&5
8304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8305 if test "${ac_cv_prog_WINDRES+set}" = set; then
8306   echo $ECHO_N "(cached) $ECHO_C" >&6
8307 else
8308   if test -n "$WINDRES"; then
8309   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8310 else
8311 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8312 for as_dir in $PATH
8313 do
8314   IFS=$as_save_IFS
8315   test -z "$as_dir" && as_dir=.
8316   for ac_exec_ext in '' $ac_executable_extensions; do
8317   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8318     ac_cv_prog_WINDRES="${ncn_progname}"
8319     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8320     break 2
8321   fi
8322 done
8323 done
8324
8325 fi
8326 fi
8327 WINDRES=$ac_cv_prog_WINDRES
8328 if test -n "$WINDRES"; then
8329   echo "$as_me:$LINENO: result: $WINDRES" >&5
8330 echo "${ECHO_T}$WINDRES" >&6
8331 else
8332   echo "$as_me:$LINENO: result: no" >&5
8333 echo "${ECHO_T}no" >&6
8334 fi
8335
8336   fi
8337   test -n "$ac_cv_prog_WINDRES" && break
8338 done
8339
8340 if test -z "$ac_cv_prog_WINDRES" ; then
8341   set dummy windres
8342   if test $build = $host ; then
8343     WINDRES="$2"
8344   else
8345     WINDRES="${ncn_tool_prefix}$2"
8346   fi
8347 fi
8348
8349
8350
8351 if test -n "$WINDMC"; then
8352   ac_cv_prog_WINDMC=$WINDMC
8353 elif test -n "$ac_cv_prog_WINDMC"; then
8354   WINDMC=$ac_cv_prog_WINDMC
8355 fi
8356
8357 if test -n "$ac_cv_prog_WINDMC"; then
8358   for ncn_progname in windmc; do
8359     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8360 set dummy ${ncn_progname}; ac_word=$2
8361 echo "$as_me:$LINENO: checking for $ac_word" >&5
8362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8363 if test "${ac_cv_prog_WINDMC+set}" = set; then
8364   echo $ECHO_N "(cached) $ECHO_C" >&6
8365 else
8366   if test -n "$WINDMC"; then
8367   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8368 else
8369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8370 for as_dir in $PATH
8371 do
8372   IFS=$as_save_IFS
8373   test -z "$as_dir" && as_dir=.
8374   for ac_exec_ext in '' $ac_executable_extensions; do
8375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8376     ac_cv_prog_WINDMC="${ncn_progname}"
8377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8378     break 2
8379   fi
8380 done
8381 done
8382
8383 fi
8384 fi
8385 WINDMC=$ac_cv_prog_WINDMC
8386 if test -n "$WINDMC"; then
8387   echo "$as_me:$LINENO: result: $WINDMC" >&5
8388 echo "${ECHO_T}$WINDMC" >&6
8389 else
8390   echo "$as_me:$LINENO: result: no" >&5
8391 echo "${ECHO_T}no" >&6
8392 fi
8393
8394   done
8395 fi
8396
8397 for ncn_progname in windmc; do
8398   if test -n "$ncn_tool_prefix"; then
8399     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8400 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8401 echo "$as_me:$LINENO: checking for $ac_word" >&5
8402 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8403 if test "${ac_cv_prog_WINDMC+set}" = set; then
8404   echo $ECHO_N "(cached) $ECHO_C" >&6
8405 else
8406   if test -n "$WINDMC"; then
8407   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8408 else
8409 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8410 for as_dir in $PATH
8411 do
8412   IFS=$as_save_IFS
8413   test -z "$as_dir" && as_dir=.
8414   for ac_exec_ext in '' $ac_executable_extensions; do
8415   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8416     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8417     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8418     break 2
8419   fi
8420 done
8421 done
8422
8423 fi
8424 fi
8425 WINDMC=$ac_cv_prog_WINDMC
8426 if test -n "$WINDMC"; then
8427   echo "$as_me:$LINENO: result: $WINDMC" >&5
8428 echo "${ECHO_T}$WINDMC" >&6
8429 else
8430   echo "$as_me:$LINENO: result: no" >&5
8431 echo "${ECHO_T}no" >&6
8432 fi
8433
8434   fi
8435   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8436     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8437 set dummy ${ncn_progname}; ac_word=$2
8438 echo "$as_me:$LINENO: checking for $ac_word" >&5
8439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8440 if test "${ac_cv_prog_WINDMC+set}" = set; then
8441   echo $ECHO_N "(cached) $ECHO_C" >&6
8442 else
8443   if test -n "$WINDMC"; then
8444   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8445 else
8446 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8447 for as_dir in $PATH
8448 do
8449   IFS=$as_save_IFS
8450   test -z "$as_dir" && as_dir=.
8451   for ac_exec_ext in '' $ac_executable_extensions; do
8452   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8453     ac_cv_prog_WINDMC="${ncn_progname}"
8454     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8455     break 2
8456   fi
8457 done
8458 done
8459
8460 fi
8461 fi
8462 WINDMC=$ac_cv_prog_WINDMC
8463 if test -n "$WINDMC"; then
8464   echo "$as_me:$LINENO: result: $WINDMC" >&5
8465 echo "${ECHO_T}$WINDMC" >&6
8466 else
8467   echo "$as_me:$LINENO: result: no" >&5
8468 echo "${ECHO_T}no" >&6
8469 fi
8470
8471   fi
8472   test -n "$ac_cv_prog_WINDMC" && break
8473 done
8474
8475 if test -z "$ac_cv_prog_WINDMC" ; then
8476   set dummy windmc
8477   if test $build = $host ; then
8478     WINDMC="$2"
8479   else
8480     WINDMC="${ncn_tool_prefix}$2"
8481   fi
8482 fi
8483
8484
8485
8486 if test -n "$OBJCOPY"; then
8487   ac_cv_prog_OBJCOPY=$OBJCOPY
8488 elif test -n "$ac_cv_prog_OBJCOPY"; then
8489   OBJCOPY=$ac_cv_prog_OBJCOPY
8490 fi
8491
8492 if test -n "$ac_cv_prog_OBJCOPY"; then
8493   for ncn_progname in objcopy; do
8494     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8495 set dummy ${ncn_progname}; ac_word=$2
8496 echo "$as_me:$LINENO: checking for $ac_word" >&5
8497 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8498 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8499   echo $ECHO_N "(cached) $ECHO_C" >&6
8500 else
8501   if test -n "$OBJCOPY"; then
8502   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8503 else
8504 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8505 for as_dir in $PATH
8506 do
8507   IFS=$as_save_IFS
8508   test -z "$as_dir" && as_dir=.
8509   for ac_exec_ext in '' $ac_executable_extensions; do
8510   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8511     ac_cv_prog_OBJCOPY="${ncn_progname}"
8512     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8513     break 2
8514   fi
8515 done
8516 done
8517
8518 fi
8519 fi
8520 OBJCOPY=$ac_cv_prog_OBJCOPY
8521 if test -n "$OBJCOPY"; then
8522   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8523 echo "${ECHO_T}$OBJCOPY" >&6
8524 else
8525   echo "$as_me:$LINENO: result: no" >&5
8526 echo "${ECHO_T}no" >&6
8527 fi
8528
8529   done
8530 fi
8531
8532 for ncn_progname in objcopy; do
8533   if test -n "$ncn_tool_prefix"; then
8534     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8535 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8536 echo "$as_me:$LINENO: checking for $ac_word" >&5
8537 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8538 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8539   echo $ECHO_N "(cached) $ECHO_C" >&6
8540 else
8541   if test -n "$OBJCOPY"; then
8542   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8543 else
8544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8545 for as_dir in $PATH
8546 do
8547   IFS=$as_save_IFS
8548   test -z "$as_dir" && as_dir=.
8549   for ac_exec_ext in '' $ac_executable_extensions; do
8550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8551     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8553     break 2
8554   fi
8555 done
8556 done
8557
8558 fi
8559 fi
8560 OBJCOPY=$ac_cv_prog_OBJCOPY
8561 if test -n "$OBJCOPY"; then
8562   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8563 echo "${ECHO_T}$OBJCOPY" >&6
8564 else
8565   echo "$as_me:$LINENO: result: no" >&5
8566 echo "${ECHO_T}no" >&6
8567 fi
8568
8569   fi
8570   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8571     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8572 set dummy ${ncn_progname}; ac_word=$2
8573 echo "$as_me:$LINENO: checking for $ac_word" >&5
8574 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8575 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8576   echo $ECHO_N "(cached) $ECHO_C" >&6
8577 else
8578   if test -n "$OBJCOPY"; then
8579   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8580 else
8581 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8582 for as_dir in $PATH
8583 do
8584   IFS=$as_save_IFS
8585   test -z "$as_dir" && as_dir=.
8586   for ac_exec_ext in '' $ac_executable_extensions; do
8587   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8588     ac_cv_prog_OBJCOPY="${ncn_progname}"
8589     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8590     break 2
8591   fi
8592 done
8593 done
8594
8595 fi
8596 fi
8597 OBJCOPY=$ac_cv_prog_OBJCOPY
8598 if test -n "$OBJCOPY"; then
8599   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8600 echo "${ECHO_T}$OBJCOPY" >&6
8601 else
8602   echo "$as_me:$LINENO: result: no" >&5
8603 echo "${ECHO_T}no" >&6
8604 fi
8605
8606   fi
8607   test -n "$ac_cv_prog_OBJCOPY" && break
8608 done
8609
8610 if test -z "$ac_cv_prog_OBJCOPY" ; then
8611   set dummy objcopy
8612   if test $build = $host ; then
8613     OBJCOPY="$2"
8614   else
8615     OBJCOPY="${ncn_tool_prefix}$2"
8616   fi
8617 fi
8618
8619
8620
8621 if test -n "$OBJDUMP"; then
8622   ac_cv_prog_OBJDUMP=$OBJDUMP
8623 elif test -n "$ac_cv_prog_OBJDUMP"; then
8624   OBJDUMP=$ac_cv_prog_OBJDUMP
8625 fi
8626
8627 if test -n "$ac_cv_prog_OBJDUMP"; then
8628   for ncn_progname in objdump; do
8629     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8630 set dummy ${ncn_progname}; ac_word=$2
8631 echo "$as_me:$LINENO: checking for $ac_word" >&5
8632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8633 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8634   echo $ECHO_N "(cached) $ECHO_C" >&6
8635 else
8636   if test -n "$OBJDUMP"; then
8637   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8638 else
8639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8640 for as_dir in $PATH
8641 do
8642   IFS=$as_save_IFS
8643   test -z "$as_dir" && as_dir=.
8644   for ac_exec_ext in '' $ac_executable_extensions; do
8645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8646     ac_cv_prog_OBJDUMP="${ncn_progname}"
8647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8648     break 2
8649   fi
8650 done
8651 done
8652
8653 fi
8654 fi
8655 OBJDUMP=$ac_cv_prog_OBJDUMP
8656 if test -n "$OBJDUMP"; then
8657   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8658 echo "${ECHO_T}$OBJDUMP" >&6
8659 else
8660   echo "$as_me:$LINENO: result: no" >&5
8661 echo "${ECHO_T}no" >&6
8662 fi
8663
8664   done
8665 fi
8666
8667 for ncn_progname in objdump; do
8668   if test -n "$ncn_tool_prefix"; then
8669     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8670 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8671 echo "$as_me:$LINENO: checking for $ac_word" >&5
8672 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8673 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8674   echo $ECHO_N "(cached) $ECHO_C" >&6
8675 else
8676   if test -n "$OBJDUMP"; then
8677   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8678 else
8679 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8680 for as_dir in $PATH
8681 do
8682   IFS=$as_save_IFS
8683   test -z "$as_dir" && as_dir=.
8684   for ac_exec_ext in '' $ac_executable_extensions; do
8685   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8686     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8687     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8688     break 2
8689   fi
8690 done
8691 done
8692
8693 fi
8694 fi
8695 OBJDUMP=$ac_cv_prog_OBJDUMP
8696 if test -n "$OBJDUMP"; then
8697   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8698 echo "${ECHO_T}$OBJDUMP" >&6
8699 else
8700   echo "$as_me:$LINENO: result: no" >&5
8701 echo "${ECHO_T}no" >&6
8702 fi
8703
8704   fi
8705   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8706     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8707 set dummy ${ncn_progname}; ac_word=$2
8708 echo "$as_me:$LINENO: checking for $ac_word" >&5
8709 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8710 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8711   echo $ECHO_N "(cached) $ECHO_C" >&6
8712 else
8713   if test -n "$OBJDUMP"; then
8714   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8715 else
8716 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8717 for as_dir in $PATH
8718 do
8719   IFS=$as_save_IFS
8720   test -z "$as_dir" && as_dir=.
8721   for ac_exec_ext in '' $ac_executable_extensions; do
8722   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8723     ac_cv_prog_OBJDUMP="${ncn_progname}"
8724     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8725     break 2
8726   fi
8727 done
8728 done
8729
8730 fi
8731 fi
8732 OBJDUMP=$ac_cv_prog_OBJDUMP
8733 if test -n "$OBJDUMP"; then
8734   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8735 echo "${ECHO_T}$OBJDUMP" >&6
8736 else
8737   echo "$as_me:$LINENO: result: no" >&5
8738 echo "${ECHO_T}no" >&6
8739 fi
8740
8741   fi
8742   test -n "$ac_cv_prog_OBJDUMP" && break
8743 done
8744
8745 if test -z "$ac_cv_prog_OBJDUMP" ; then
8746   set dummy objdump
8747   if test $build = $host ; then
8748     OBJDUMP="$2"
8749   else
8750     OBJDUMP="${ncn_tool_prefix}$2"
8751   fi
8752 fi
8753
8754
8755
8756
8757
8758
8759 # Target tools.
8760
8761 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8762 if test "${with_build_time_tools+set}" = set; then
8763   withval="$with_build_time_tools"
8764   case x"$withval" in
8765      x/*) ;;
8766      *)
8767        with_build_time_tools=
8768        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8769 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8770        ;;
8771    esac
8772 else
8773   with_build_time_tools=
8774 fi;
8775
8776
8777
8778 if test -n "$CC_FOR_TARGET"; then
8779   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8780 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8781   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8782 fi
8783
8784 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8785   for ncn_progname in cc gcc; do
8786     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8787 set dummy ${ncn_progname}; ac_word=$2
8788 echo "$as_me:$LINENO: checking for $ac_word" >&5
8789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8790 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8791   echo $ECHO_N "(cached) $ECHO_C" >&6
8792 else
8793   if test -n "$CC_FOR_TARGET"; then
8794   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8795 else
8796 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8797 for as_dir in $PATH
8798 do
8799   IFS=$as_save_IFS
8800   test -z "$as_dir" && as_dir=.
8801   for ac_exec_ext in '' $ac_executable_extensions; do
8802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8803     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8805     break 2
8806   fi
8807 done
8808 done
8809
8810 fi
8811 fi
8812 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8813 if test -n "$CC_FOR_TARGET"; then
8814   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8815 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8816 else
8817   echo "$as_me:$LINENO: result: no" >&5
8818 echo "${ECHO_T}no" >&6
8819 fi
8820
8821   done
8822 fi
8823
8824 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8825   for ncn_progname in cc gcc; do
8826     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8827 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8828     if test -x $with_build_time_tools/${ncn_progname}; then
8829       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8830       echo "$as_me:$LINENO: result: yes" >&5
8831 echo "${ECHO_T}yes" >&6
8832       break
8833     else
8834       echo "$as_me:$LINENO: result: no" >&5
8835 echo "${ECHO_T}no" >&6
8836     fi
8837   done
8838 fi
8839
8840 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8841   for ncn_progname in cc gcc; do
8842     if test -n "$ncn_target_tool_prefix"; then
8843       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8844 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8845 echo "$as_me:$LINENO: checking for $ac_word" >&5
8846 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8847 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8848   echo $ECHO_N "(cached) $ECHO_C" >&6
8849 else
8850   if test -n "$CC_FOR_TARGET"; then
8851   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8852 else
8853 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8854 for as_dir in $PATH
8855 do
8856   IFS=$as_save_IFS
8857   test -z "$as_dir" && as_dir=.
8858   for ac_exec_ext in '' $ac_executable_extensions; do
8859   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8860     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8861     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8862     break 2
8863   fi
8864 done
8865 done
8866
8867 fi
8868 fi
8869 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8870 if test -n "$CC_FOR_TARGET"; then
8871   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8872 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8873 else
8874   echo "$as_me:$LINENO: result: no" >&5
8875 echo "${ECHO_T}no" >&6
8876 fi
8877
8878     fi
8879     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8880       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8881 set dummy ${ncn_progname}; ac_word=$2
8882 echo "$as_me:$LINENO: checking for $ac_word" >&5
8883 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8884 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8885   echo $ECHO_N "(cached) $ECHO_C" >&6
8886 else
8887   if test -n "$CC_FOR_TARGET"; then
8888   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8889 else
8890 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8891 for as_dir in $PATH
8892 do
8893   IFS=$as_save_IFS
8894   test -z "$as_dir" && as_dir=.
8895   for ac_exec_ext in '' $ac_executable_extensions; do
8896   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8897     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8898     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8899     break 2
8900   fi
8901 done
8902 done
8903
8904 fi
8905 fi
8906 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8907 if test -n "$CC_FOR_TARGET"; then
8908   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8909 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8910 else
8911   echo "$as_me:$LINENO: result: no" >&5
8912 echo "${ECHO_T}no" >&6
8913 fi
8914
8915     fi
8916     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8917   done
8918 fi
8919
8920 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8921   set dummy cc gcc
8922   if test $build = $target ; then
8923     CC_FOR_TARGET="$2"
8924   else
8925     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8926   fi
8927 else
8928   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8929 fi
8930
8931
8932
8933 if test -n "$CXX_FOR_TARGET"; then
8934   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8935 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8936   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8937 fi
8938
8939 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8940   for ncn_progname in c++ g++ cxx gxx; do
8941     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8942 set dummy ${ncn_progname}; ac_word=$2
8943 echo "$as_me:$LINENO: checking for $ac_word" >&5
8944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8945 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8946   echo $ECHO_N "(cached) $ECHO_C" >&6
8947 else
8948   if test -n "$CXX_FOR_TARGET"; then
8949   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8950 else
8951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8952 for as_dir in $PATH
8953 do
8954   IFS=$as_save_IFS
8955   test -z "$as_dir" && as_dir=.
8956   for ac_exec_ext in '' $ac_executable_extensions; do
8957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8958     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8959     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8960     break 2
8961   fi
8962 done
8963 done
8964
8965 fi
8966 fi
8967 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8968 if test -n "$CXX_FOR_TARGET"; then
8969   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8970 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8971 else
8972   echo "$as_me:$LINENO: result: no" >&5
8973 echo "${ECHO_T}no" >&6
8974 fi
8975
8976   done
8977 fi
8978
8979 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8980   for ncn_progname in c++ g++ cxx gxx; do
8981     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8982 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8983     if test -x $with_build_time_tools/${ncn_progname}; then
8984       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8985       echo "$as_me:$LINENO: result: yes" >&5
8986 echo "${ECHO_T}yes" >&6
8987       break
8988     else
8989       echo "$as_me:$LINENO: result: no" >&5
8990 echo "${ECHO_T}no" >&6
8991     fi
8992   done
8993 fi
8994
8995 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8996   for ncn_progname in c++ g++ cxx gxx; do
8997     if test -n "$ncn_target_tool_prefix"; then
8998       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8999 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9000 echo "$as_me:$LINENO: checking for $ac_word" >&5
9001 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9002 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9003   echo $ECHO_N "(cached) $ECHO_C" >&6
9004 else
9005   if test -n "$CXX_FOR_TARGET"; then
9006   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9007 else
9008 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9009 for as_dir in $PATH
9010 do
9011   IFS=$as_save_IFS
9012   test -z "$as_dir" && as_dir=.
9013   for ac_exec_ext in '' $ac_executable_extensions; do
9014   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9015     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9016     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9017     break 2
9018   fi
9019 done
9020 done
9021
9022 fi
9023 fi
9024 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9025 if test -n "$CXX_FOR_TARGET"; then
9026   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9027 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9028 else
9029   echo "$as_me:$LINENO: result: no" >&5
9030 echo "${ECHO_T}no" >&6
9031 fi
9032
9033     fi
9034     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
9035       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9036 set dummy ${ncn_progname}; ac_word=$2
9037 echo "$as_me:$LINENO: checking for $ac_word" >&5
9038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9039 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
9040   echo $ECHO_N "(cached) $ECHO_C" >&6
9041 else
9042   if test -n "$CXX_FOR_TARGET"; then
9043   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
9044 else
9045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9046 for as_dir in $PATH
9047 do
9048   IFS=$as_save_IFS
9049   test -z "$as_dir" && as_dir=.
9050   for ac_exec_ext in '' $ac_executable_extensions; do
9051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9052     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
9053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9054     break 2
9055   fi
9056 done
9057 done
9058
9059 fi
9060 fi
9061 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
9062 if test -n "$CXX_FOR_TARGET"; then
9063   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
9064 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
9065 else
9066   echo "$as_me:$LINENO: result: no" >&5
9067 echo "${ECHO_T}no" >&6
9068 fi
9069
9070     fi
9071     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
9072   done
9073 fi
9074
9075 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
9076   set dummy c++ g++ cxx gxx
9077   if test $build = $target ; then
9078     CXX_FOR_TARGET="$2"
9079   else
9080     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
9081   fi
9082 else
9083   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
9084 fi
9085
9086
9087
9088 if test -n "$GCC_FOR_TARGET"; then
9089   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
9090 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9091   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9092 fi
9093
9094 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
9095   for ncn_progname in gcc; do
9096     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9097 set dummy ${ncn_progname}; ac_word=$2
9098 echo "$as_me:$LINENO: checking for $ac_word" >&5
9099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9100 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9101   echo $ECHO_N "(cached) $ECHO_C" >&6
9102 else
9103   if test -n "$GCC_FOR_TARGET"; then
9104   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9105 else
9106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9107 for as_dir in $PATH
9108 do
9109   IFS=$as_save_IFS
9110   test -z "$as_dir" && as_dir=.
9111   for ac_exec_ext in '' $ac_executable_extensions; do
9112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9113     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9115     break 2
9116   fi
9117 done
9118 done
9119
9120 fi
9121 fi
9122 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9123 if test -n "$GCC_FOR_TARGET"; then
9124   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9125 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9126 else
9127   echo "$as_me:$LINENO: result: no" >&5
9128 echo "${ECHO_T}no" >&6
9129 fi
9130
9131   done
9132 fi
9133
9134 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9135   for ncn_progname in gcc; do
9136     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9137 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9138     if test -x $with_build_time_tools/${ncn_progname}; then
9139       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9140       echo "$as_me:$LINENO: result: yes" >&5
9141 echo "${ECHO_T}yes" >&6
9142       break
9143     else
9144       echo "$as_me:$LINENO: result: no" >&5
9145 echo "${ECHO_T}no" >&6
9146     fi
9147   done
9148 fi
9149
9150 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9151   for ncn_progname in gcc; do
9152     if test -n "$ncn_target_tool_prefix"; then
9153       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9154 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9155 echo "$as_me:$LINENO: checking for $ac_word" >&5
9156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9157 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9158   echo $ECHO_N "(cached) $ECHO_C" >&6
9159 else
9160   if test -n "$GCC_FOR_TARGET"; then
9161   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9162 else
9163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9164 for as_dir in $PATH
9165 do
9166   IFS=$as_save_IFS
9167   test -z "$as_dir" && as_dir=.
9168   for ac_exec_ext in '' $ac_executable_extensions; do
9169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9170     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9172     break 2
9173   fi
9174 done
9175 done
9176
9177 fi
9178 fi
9179 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9180 if test -n "$GCC_FOR_TARGET"; then
9181   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9182 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9183 else
9184   echo "$as_me:$LINENO: result: no" >&5
9185 echo "${ECHO_T}no" >&6
9186 fi
9187
9188     fi
9189     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9190       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9191 set dummy ${ncn_progname}; ac_word=$2
9192 echo "$as_me:$LINENO: checking for $ac_word" >&5
9193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9194 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9195   echo $ECHO_N "(cached) $ECHO_C" >&6
9196 else
9197   if test -n "$GCC_FOR_TARGET"; then
9198   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9199 else
9200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9201 for as_dir in $PATH
9202 do
9203   IFS=$as_save_IFS
9204   test -z "$as_dir" && as_dir=.
9205   for ac_exec_ext in '' $ac_executable_extensions; do
9206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9207     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9209     break 2
9210   fi
9211 done
9212 done
9213
9214 fi
9215 fi
9216 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9217 if test -n "$GCC_FOR_TARGET"; then
9218   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9219 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9220 else
9221   echo "$as_me:$LINENO: result: no" >&5
9222 echo "${ECHO_T}no" >&6
9223 fi
9224
9225     fi
9226     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9227   done
9228 fi
9229
9230 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9231   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9232 else
9233   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9234 fi
9235
9236
9237
9238 if test -n "$GCJ_FOR_TARGET"; then
9239   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9240 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9241   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9242 fi
9243
9244 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9245   for ncn_progname in gcj; do
9246     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9247 set dummy ${ncn_progname}; ac_word=$2
9248 echo "$as_me:$LINENO: checking for $ac_word" >&5
9249 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9250 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9251   echo $ECHO_N "(cached) $ECHO_C" >&6
9252 else
9253   if test -n "$GCJ_FOR_TARGET"; then
9254   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9255 else
9256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9257 for as_dir in $PATH
9258 do
9259   IFS=$as_save_IFS
9260   test -z "$as_dir" && as_dir=.
9261   for ac_exec_ext in '' $ac_executable_extensions; do
9262   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9263     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9265     break 2
9266   fi
9267 done
9268 done
9269
9270 fi
9271 fi
9272 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9273 if test -n "$GCJ_FOR_TARGET"; then
9274   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9275 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9276 else
9277   echo "$as_me:$LINENO: result: no" >&5
9278 echo "${ECHO_T}no" >&6
9279 fi
9280
9281   done
9282 fi
9283
9284 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9285   for ncn_progname in gcj; do
9286     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9287 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9288     if test -x $with_build_time_tools/${ncn_progname}; then
9289       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9290       echo "$as_me:$LINENO: result: yes" >&5
9291 echo "${ECHO_T}yes" >&6
9292       break
9293     else
9294       echo "$as_me:$LINENO: result: no" >&5
9295 echo "${ECHO_T}no" >&6
9296     fi
9297   done
9298 fi
9299
9300 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9301   for ncn_progname in gcj; do
9302     if test -n "$ncn_target_tool_prefix"; then
9303       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9304 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9305 echo "$as_me:$LINENO: checking for $ac_word" >&5
9306 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9307 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9308   echo $ECHO_N "(cached) $ECHO_C" >&6
9309 else
9310   if test -n "$GCJ_FOR_TARGET"; then
9311   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9312 else
9313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9314 for as_dir in $PATH
9315 do
9316   IFS=$as_save_IFS
9317   test -z "$as_dir" && as_dir=.
9318   for ac_exec_ext in '' $ac_executable_extensions; do
9319   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9320     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9321     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9322     break 2
9323   fi
9324 done
9325 done
9326
9327 fi
9328 fi
9329 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9330 if test -n "$GCJ_FOR_TARGET"; then
9331   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9332 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9333 else
9334   echo "$as_me:$LINENO: result: no" >&5
9335 echo "${ECHO_T}no" >&6
9336 fi
9337
9338     fi
9339     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9340       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9341 set dummy ${ncn_progname}; ac_word=$2
9342 echo "$as_me:$LINENO: checking for $ac_word" >&5
9343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9344 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9345   echo $ECHO_N "(cached) $ECHO_C" >&6
9346 else
9347   if test -n "$GCJ_FOR_TARGET"; then
9348   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9349 else
9350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9351 for as_dir in $PATH
9352 do
9353   IFS=$as_save_IFS
9354   test -z "$as_dir" && as_dir=.
9355   for ac_exec_ext in '' $ac_executable_extensions; do
9356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9357     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9359     break 2
9360   fi
9361 done
9362 done
9363
9364 fi
9365 fi
9366 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9367 if test -n "$GCJ_FOR_TARGET"; then
9368   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9369 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9370 else
9371   echo "$as_me:$LINENO: result: no" >&5
9372 echo "${ECHO_T}no" >&6
9373 fi
9374
9375     fi
9376     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9377   done
9378 fi
9379
9380 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9381   set dummy gcj
9382   if test $build = $target ; then
9383     GCJ_FOR_TARGET="$2"
9384   else
9385     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9386   fi
9387 else
9388   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9389 fi
9390
9391
9392
9393 if test -n "$GFORTRAN_FOR_TARGET"; then
9394   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9395 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9396   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9397 fi
9398
9399 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9400   for ncn_progname in gfortran; do
9401     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9402 set dummy ${ncn_progname}; ac_word=$2
9403 echo "$as_me:$LINENO: checking for $ac_word" >&5
9404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9405 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9406   echo $ECHO_N "(cached) $ECHO_C" >&6
9407 else
9408   if test -n "$GFORTRAN_FOR_TARGET"; then
9409   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9410 else
9411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9412 for as_dir in $PATH
9413 do
9414   IFS=$as_save_IFS
9415   test -z "$as_dir" && as_dir=.
9416   for ac_exec_ext in '' $ac_executable_extensions; do
9417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9418     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9420     break 2
9421   fi
9422 done
9423 done
9424
9425 fi
9426 fi
9427 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9428 if test -n "$GFORTRAN_FOR_TARGET"; then
9429   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9430 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9431 else
9432   echo "$as_me:$LINENO: result: no" >&5
9433 echo "${ECHO_T}no" >&6
9434 fi
9435
9436   done
9437 fi
9438
9439 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9440   for ncn_progname in gfortran; do
9441     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9442 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9443     if test -x $with_build_time_tools/${ncn_progname}; then
9444       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9445       echo "$as_me:$LINENO: result: yes" >&5
9446 echo "${ECHO_T}yes" >&6
9447       break
9448     else
9449       echo "$as_me:$LINENO: result: no" >&5
9450 echo "${ECHO_T}no" >&6
9451     fi
9452   done
9453 fi
9454
9455 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9456   for ncn_progname in gfortran; do
9457     if test -n "$ncn_target_tool_prefix"; then
9458       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9459 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9460 echo "$as_me:$LINENO: checking for $ac_word" >&5
9461 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9462 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9463   echo $ECHO_N "(cached) $ECHO_C" >&6
9464 else
9465   if test -n "$GFORTRAN_FOR_TARGET"; then
9466   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9467 else
9468 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9469 for as_dir in $PATH
9470 do
9471   IFS=$as_save_IFS
9472   test -z "$as_dir" && as_dir=.
9473   for ac_exec_ext in '' $ac_executable_extensions; do
9474   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9475     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9476     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9477     break 2
9478   fi
9479 done
9480 done
9481
9482 fi
9483 fi
9484 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9485 if test -n "$GFORTRAN_FOR_TARGET"; then
9486   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9487 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9488 else
9489   echo "$as_me:$LINENO: result: no" >&5
9490 echo "${ECHO_T}no" >&6
9491 fi
9492
9493     fi
9494     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9495       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9496 set dummy ${ncn_progname}; ac_word=$2
9497 echo "$as_me:$LINENO: checking for $ac_word" >&5
9498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9499 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9500   echo $ECHO_N "(cached) $ECHO_C" >&6
9501 else
9502   if test -n "$GFORTRAN_FOR_TARGET"; then
9503   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9504 else
9505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9506 for as_dir in $PATH
9507 do
9508   IFS=$as_save_IFS
9509   test -z "$as_dir" && as_dir=.
9510   for ac_exec_ext in '' $ac_executable_extensions; do
9511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9512     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9514     break 2
9515   fi
9516 done
9517 done
9518
9519 fi
9520 fi
9521 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9522 if test -n "$GFORTRAN_FOR_TARGET"; then
9523   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9524 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9525 else
9526   echo "$as_me:$LINENO: result: no" >&5
9527 echo "${ECHO_T}no" >&6
9528 fi
9529
9530     fi
9531     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9532   done
9533 fi
9534
9535 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9536   set dummy gfortran
9537   if test $build = $target ; then
9538     GFORTRAN_FOR_TARGET="$2"
9539   else
9540     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9541   fi
9542 else
9543   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9544 fi
9545
9546
9547
9548 cat > conftest.c << \EOF
9549 #ifdef __GNUC__
9550   gcc_yay;
9551 #endif
9552 EOF
9553 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9554   have_gcc_for_target=yes
9555 else
9556   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9557   have_gcc_for_target=no
9558 fi
9559 rm conftest.c
9560
9561
9562
9563
9564 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9565   if test -n "$with_build_time_tools"; then
9566     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9567 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9568     if test -x $with_build_time_tools/ar; then
9569       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9570       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9571       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9572 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9573     else
9574       echo "$as_me:$LINENO: result: no" >&5
9575 echo "${ECHO_T}no" >&6
9576     fi
9577   elif test $build != $host && test $have_gcc_for_target = yes; then
9578     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9579     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9580     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9581   fi
9582 fi
9583 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9584   # Extract the first word of "ar", so it can be a program name with args.
9585 set dummy ar; ac_word=$2
9586 echo "$as_me:$LINENO: checking for $ac_word" >&5
9587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9588 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9589   echo $ECHO_N "(cached) $ECHO_C" >&6
9590 else
9591   case $AR_FOR_TARGET in
9592   [\\/]* | ?:[\\/]*)
9593   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9594   ;;
9595   *)
9596   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9597 for as_dir in $gcc_cv_tool_dirs
9598 do
9599   IFS=$as_save_IFS
9600   test -z "$as_dir" && as_dir=.
9601   for ac_exec_ext in '' $ac_executable_extensions; do
9602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9603     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9605     break 2
9606   fi
9607 done
9608 done
9609
9610   ;;
9611 esac
9612 fi
9613 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9614
9615 if test -n "$AR_FOR_TARGET"; then
9616   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9617 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9618 else
9619   echo "$as_me:$LINENO: result: no" >&5
9620 echo "${ECHO_T}no" >&6
9621 fi
9622
9623 fi
9624 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9625
9626
9627 if test -n "$AR_FOR_TARGET"; then
9628   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9629 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9630   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9631 fi
9632
9633 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9634   for ncn_progname in ar; do
9635     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9636 set dummy ${ncn_progname}; ac_word=$2
9637 echo "$as_me:$LINENO: checking for $ac_word" >&5
9638 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9639 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9640   echo $ECHO_N "(cached) $ECHO_C" >&6
9641 else
9642   if test -n "$AR_FOR_TARGET"; then
9643   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9644 else
9645 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9646 for as_dir in $PATH
9647 do
9648   IFS=$as_save_IFS
9649   test -z "$as_dir" && as_dir=.
9650   for ac_exec_ext in '' $ac_executable_extensions; do
9651   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9652     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9653     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9654     break 2
9655   fi
9656 done
9657 done
9658
9659 fi
9660 fi
9661 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9662 if test -n "$AR_FOR_TARGET"; then
9663   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9664 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9665 else
9666   echo "$as_me:$LINENO: result: no" >&5
9667 echo "${ECHO_T}no" >&6
9668 fi
9669
9670   done
9671 fi
9672
9673 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9674   for ncn_progname in ar; do
9675     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9676 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9677     if test -x $with_build_time_tools/${ncn_progname}; then
9678       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9679       echo "$as_me:$LINENO: result: yes" >&5
9680 echo "${ECHO_T}yes" >&6
9681       break
9682     else
9683       echo "$as_me:$LINENO: result: no" >&5
9684 echo "${ECHO_T}no" >&6
9685     fi
9686   done
9687 fi
9688
9689 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9690   for ncn_progname in ar; do
9691     if test -n "$ncn_target_tool_prefix"; then
9692       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9693 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9694 echo "$as_me:$LINENO: checking for $ac_word" >&5
9695 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9696 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9697   echo $ECHO_N "(cached) $ECHO_C" >&6
9698 else
9699   if test -n "$AR_FOR_TARGET"; then
9700   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9701 else
9702 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9703 for as_dir in $PATH
9704 do
9705   IFS=$as_save_IFS
9706   test -z "$as_dir" && as_dir=.
9707   for ac_exec_ext in '' $ac_executable_extensions; do
9708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9709     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9711     break 2
9712   fi
9713 done
9714 done
9715
9716 fi
9717 fi
9718 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9719 if test -n "$AR_FOR_TARGET"; then
9720   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9721 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9722 else
9723   echo "$as_me:$LINENO: result: no" >&5
9724 echo "${ECHO_T}no" >&6
9725 fi
9726
9727     fi
9728     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9729       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9730 set dummy ${ncn_progname}; ac_word=$2
9731 echo "$as_me:$LINENO: checking for $ac_word" >&5
9732 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9733 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9734   echo $ECHO_N "(cached) $ECHO_C" >&6
9735 else
9736   if test -n "$AR_FOR_TARGET"; then
9737   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9738 else
9739 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9740 for as_dir in $PATH
9741 do
9742   IFS=$as_save_IFS
9743   test -z "$as_dir" && as_dir=.
9744   for ac_exec_ext in '' $ac_executable_extensions; do
9745   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9746     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9747     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9748     break 2
9749   fi
9750 done
9751 done
9752
9753 fi
9754 fi
9755 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9756 if test -n "$AR_FOR_TARGET"; then
9757   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9758 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9759 else
9760   echo "$as_me:$LINENO: result: no" >&5
9761 echo "${ECHO_T}no" >&6
9762 fi
9763
9764     fi
9765     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9766   done
9767 fi
9768
9769 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9770   set dummy ar
9771   if test $build = $target ; then
9772     AR_FOR_TARGET="$2"
9773   else
9774     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9775   fi
9776 else
9777   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9778 fi
9779
9780 else
9781   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9782 fi
9783
9784
9785
9786
9787 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9788   if test -n "$with_build_time_tools"; then
9789     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9790 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9791     if test -x $with_build_time_tools/as; then
9792       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9793       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9794       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9795 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9796     else
9797       echo "$as_me:$LINENO: result: no" >&5
9798 echo "${ECHO_T}no" >&6
9799     fi
9800   elif test $build != $host && test $have_gcc_for_target = yes; then
9801     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9802     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9803     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9804   fi
9805 fi
9806 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9807   # Extract the first word of "as", so it can be a program name with args.
9808 set dummy as; ac_word=$2
9809 echo "$as_me:$LINENO: checking for $ac_word" >&5
9810 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9811 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9812   echo $ECHO_N "(cached) $ECHO_C" >&6
9813 else
9814   case $AS_FOR_TARGET in
9815   [\\/]* | ?:[\\/]*)
9816   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9817   ;;
9818   *)
9819   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9820 for as_dir in $gcc_cv_tool_dirs
9821 do
9822   IFS=$as_save_IFS
9823   test -z "$as_dir" && as_dir=.
9824   for ac_exec_ext in '' $ac_executable_extensions; do
9825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9826     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9828     break 2
9829   fi
9830 done
9831 done
9832
9833   ;;
9834 esac
9835 fi
9836 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9837
9838 if test -n "$AS_FOR_TARGET"; then
9839   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9840 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9841 else
9842   echo "$as_me:$LINENO: result: no" >&5
9843 echo "${ECHO_T}no" >&6
9844 fi
9845
9846 fi
9847 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9848
9849
9850 if test -n "$AS_FOR_TARGET"; then
9851   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9852 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9853   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9854 fi
9855
9856 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9857   for ncn_progname in as; do
9858     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9859 set dummy ${ncn_progname}; ac_word=$2
9860 echo "$as_me:$LINENO: checking for $ac_word" >&5
9861 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9862 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9863   echo $ECHO_N "(cached) $ECHO_C" >&6
9864 else
9865   if test -n "$AS_FOR_TARGET"; then
9866   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9867 else
9868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9869 for as_dir in $PATH
9870 do
9871   IFS=$as_save_IFS
9872   test -z "$as_dir" && as_dir=.
9873   for ac_exec_ext in '' $ac_executable_extensions; do
9874   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9875     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9876     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9877     break 2
9878   fi
9879 done
9880 done
9881
9882 fi
9883 fi
9884 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9885 if test -n "$AS_FOR_TARGET"; then
9886   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9887 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9888 else
9889   echo "$as_me:$LINENO: result: no" >&5
9890 echo "${ECHO_T}no" >&6
9891 fi
9892
9893   done
9894 fi
9895
9896 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9897   for ncn_progname in as; do
9898     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9899 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9900     if test -x $with_build_time_tools/${ncn_progname}; then
9901       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9902       echo "$as_me:$LINENO: result: yes" >&5
9903 echo "${ECHO_T}yes" >&6
9904       break
9905     else
9906       echo "$as_me:$LINENO: result: no" >&5
9907 echo "${ECHO_T}no" >&6
9908     fi
9909   done
9910 fi
9911
9912 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9913   for ncn_progname in as; do
9914     if test -n "$ncn_target_tool_prefix"; then
9915       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9916 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9917 echo "$as_me:$LINENO: checking for $ac_word" >&5
9918 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9919 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9920   echo $ECHO_N "(cached) $ECHO_C" >&6
9921 else
9922   if test -n "$AS_FOR_TARGET"; then
9923   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9924 else
9925 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9926 for as_dir in $PATH
9927 do
9928   IFS=$as_save_IFS
9929   test -z "$as_dir" && as_dir=.
9930   for ac_exec_ext in '' $ac_executable_extensions; do
9931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9932     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9934     break 2
9935   fi
9936 done
9937 done
9938
9939 fi
9940 fi
9941 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9942 if test -n "$AS_FOR_TARGET"; then
9943   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9944 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9945 else
9946   echo "$as_me:$LINENO: result: no" >&5
9947 echo "${ECHO_T}no" >&6
9948 fi
9949
9950     fi
9951     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9952       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9953 set dummy ${ncn_progname}; ac_word=$2
9954 echo "$as_me:$LINENO: checking for $ac_word" >&5
9955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9956 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9957   echo $ECHO_N "(cached) $ECHO_C" >&6
9958 else
9959   if test -n "$AS_FOR_TARGET"; then
9960   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9961 else
9962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9963 for as_dir in $PATH
9964 do
9965   IFS=$as_save_IFS
9966   test -z "$as_dir" && as_dir=.
9967   for ac_exec_ext in '' $ac_executable_extensions; do
9968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9969     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9971     break 2
9972   fi
9973 done
9974 done
9975
9976 fi
9977 fi
9978 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9979 if test -n "$AS_FOR_TARGET"; then
9980   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9981 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9982 else
9983   echo "$as_me:$LINENO: result: no" >&5
9984 echo "${ECHO_T}no" >&6
9985 fi
9986
9987     fi
9988     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9989   done
9990 fi
9991
9992 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9993   set dummy as
9994   if test $build = $target ; then
9995     AS_FOR_TARGET="$2"
9996   else
9997     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9998   fi
9999 else
10000   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
10001 fi
10002
10003 else
10004   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
10005 fi
10006
10007
10008
10009
10010 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10011   if test -n "$with_build_time_tools"; then
10012     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
10013 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
10014     if test -x $with_build_time_tools/dlltool; then
10015       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
10016       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10017       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
10018 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
10019     else
10020       echo "$as_me:$LINENO: result: no" >&5
10021 echo "${ECHO_T}no" >&6
10022     fi
10023   elif test $build != $host && test $have_gcc_for_target = yes; then
10024     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
10025     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
10026     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10027   fi
10028 fi
10029 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10030   # Extract the first word of "dlltool", so it can be a program name with args.
10031 set dummy dlltool; ac_word=$2
10032 echo "$as_me:$LINENO: checking for $ac_word" >&5
10033 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10034 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
10035   echo $ECHO_N "(cached) $ECHO_C" >&6
10036 else
10037   case $DLLTOOL_FOR_TARGET in
10038   [\\/]* | ?:[\\/]*)
10039   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
10040   ;;
10041   *)
10042   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10043 for as_dir in $gcc_cv_tool_dirs
10044 do
10045   IFS=$as_save_IFS
10046   test -z "$as_dir" && as_dir=.
10047   for ac_exec_ext in '' $ac_executable_extensions; do
10048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10049     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10051     break 2
10052   fi
10053 done
10054 done
10055
10056   ;;
10057 esac
10058 fi
10059 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10060
10061 if test -n "$DLLTOOL_FOR_TARGET"; then
10062   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10063 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10064 else
10065   echo "$as_me:$LINENO: result: no" >&5
10066 echo "${ECHO_T}no" >&6
10067 fi
10068
10069 fi
10070 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
10071
10072
10073 if test -n "$DLLTOOL_FOR_TARGET"; then
10074   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
10075 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10076   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10077 fi
10078
10079 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10080   for ncn_progname in dlltool; do
10081     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10082 set dummy ${ncn_progname}; ac_word=$2
10083 echo "$as_me:$LINENO: checking for $ac_word" >&5
10084 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10085 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10086   echo $ECHO_N "(cached) $ECHO_C" >&6
10087 else
10088   if test -n "$DLLTOOL_FOR_TARGET"; then
10089   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10090 else
10091 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10092 for as_dir in $PATH
10093 do
10094   IFS=$as_save_IFS
10095   test -z "$as_dir" && as_dir=.
10096   for ac_exec_ext in '' $ac_executable_extensions; do
10097   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10098     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10099     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10100     break 2
10101   fi
10102 done
10103 done
10104
10105 fi
10106 fi
10107 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10108 if test -n "$DLLTOOL_FOR_TARGET"; then
10109   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10110 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10111 else
10112   echo "$as_me:$LINENO: result: no" >&5
10113 echo "${ECHO_T}no" >&6
10114 fi
10115
10116   done
10117 fi
10118
10119 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10120   for ncn_progname in dlltool; do
10121     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10122 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10123     if test -x $with_build_time_tools/${ncn_progname}; then
10124       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10125       echo "$as_me:$LINENO: result: yes" >&5
10126 echo "${ECHO_T}yes" >&6
10127       break
10128     else
10129       echo "$as_me:$LINENO: result: no" >&5
10130 echo "${ECHO_T}no" >&6
10131     fi
10132   done
10133 fi
10134
10135 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10136   for ncn_progname in dlltool; do
10137     if test -n "$ncn_target_tool_prefix"; then
10138       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10139 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10140 echo "$as_me:$LINENO: checking for $ac_word" >&5
10141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10142 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10143   echo $ECHO_N "(cached) $ECHO_C" >&6
10144 else
10145   if test -n "$DLLTOOL_FOR_TARGET"; then
10146   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10147 else
10148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10149 for as_dir in $PATH
10150 do
10151   IFS=$as_save_IFS
10152   test -z "$as_dir" && as_dir=.
10153   for ac_exec_ext in '' $ac_executable_extensions; do
10154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10155     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10157     break 2
10158   fi
10159 done
10160 done
10161
10162 fi
10163 fi
10164 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10165 if test -n "$DLLTOOL_FOR_TARGET"; then
10166   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10167 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10168 else
10169   echo "$as_me:$LINENO: result: no" >&5
10170 echo "${ECHO_T}no" >&6
10171 fi
10172
10173     fi
10174     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10175       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10176 set dummy ${ncn_progname}; ac_word=$2
10177 echo "$as_me:$LINENO: checking for $ac_word" >&5
10178 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10179 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10180   echo $ECHO_N "(cached) $ECHO_C" >&6
10181 else
10182   if test -n "$DLLTOOL_FOR_TARGET"; then
10183   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10184 else
10185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10186 for as_dir in $PATH
10187 do
10188   IFS=$as_save_IFS
10189   test -z "$as_dir" && as_dir=.
10190   for ac_exec_ext in '' $ac_executable_extensions; do
10191   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10192     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10193     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10194     break 2
10195   fi
10196 done
10197 done
10198
10199 fi
10200 fi
10201 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10202 if test -n "$DLLTOOL_FOR_TARGET"; then
10203   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10204 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10205 else
10206   echo "$as_me:$LINENO: result: no" >&5
10207 echo "${ECHO_T}no" >&6
10208 fi
10209
10210     fi
10211     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10212   done
10213 fi
10214
10215 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10216   set dummy dlltool
10217   if test $build = $target ; then
10218     DLLTOOL_FOR_TARGET="$2"
10219   else
10220     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10221   fi
10222 else
10223   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10224 fi
10225
10226 else
10227   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10228 fi
10229
10230
10231
10232
10233 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10234   if test -n "$with_build_time_tools"; then
10235     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10236 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10237     if test -x $with_build_time_tools/ld; then
10238       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10239       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10240       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10241 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10242     else
10243       echo "$as_me:$LINENO: result: no" >&5
10244 echo "${ECHO_T}no" >&6
10245     fi
10246   elif test $build != $host && test $have_gcc_for_target = yes; then
10247     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10248     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10249     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10250   fi
10251 fi
10252 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10253   # Extract the first word of "ld", so it can be a program name with args.
10254 set dummy ld; ac_word=$2
10255 echo "$as_me:$LINENO: checking for $ac_word" >&5
10256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10257 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10258   echo $ECHO_N "(cached) $ECHO_C" >&6
10259 else
10260   case $LD_FOR_TARGET in
10261   [\\/]* | ?:[\\/]*)
10262   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10263   ;;
10264   *)
10265   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10266 for as_dir in $gcc_cv_tool_dirs
10267 do
10268   IFS=$as_save_IFS
10269   test -z "$as_dir" && as_dir=.
10270   for ac_exec_ext in '' $ac_executable_extensions; do
10271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10272     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10274     break 2
10275   fi
10276 done
10277 done
10278
10279   ;;
10280 esac
10281 fi
10282 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10283
10284 if test -n "$LD_FOR_TARGET"; then
10285   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10286 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10287 else
10288   echo "$as_me:$LINENO: result: no" >&5
10289 echo "${ECHO_T}no" >&6
10290 fi
10291
10292 fi
10293 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10294
10295
10296 if test -n "$LD_FOR_TARGET"; then
10297   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10298 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10299   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10300 fi
10301
10302 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10303   for ncn_progname in ld; do
10304     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10305 set dummy ${ncn_progname}; ac_word=$2
10306 echo "$as_me:$LINENO: checking for $ac_word" >&5
10307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10308 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10309   echo $ECHO_N "(cached) $ECHO_C" >&6
10310 else
10311   if test -n "$LD_FOR_TARGET"; then
10312   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10313 else
10314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10315 for as_dir in $PATH
10316 do
10317   IFS=$as_save_IFS
10318   test -z "$as_dir" && as_dir=.
10319   for ac_exec_ext in '' $ac_executable_extensions; do
10320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10321     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10323     break 2
10324   fi
10325 done
10326 done
10327
10328 fi
10329 fi
10330 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10331 if test -n "$LD_FOR_TARGET"; then
10332   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10333 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10334 else
10335   echo "$as_me:$LINENO: result: no" >&5
10336 echo "${ECHO_T}no" >&6
10337 fi
10338
10339   done
10340 fi
10341
10342 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10343   for ncn_progname in ld; do
10344     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10345 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10346     if test -x $with_build_time_tools/${ncn_progname}; then
10347       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10348       echo "$as_me:$LINENO: result: yes" >&5
10349 echo "${ECHO_T}yes" >&6
10350       break
10351     else
10352       echo "$as_me:$LINENO: result: no" >&5
10353 echo "${ECHO_T}no" >&6
10354     fi
10355   done
10356 fi
10357
10358 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10359   for ncn_progname in ld; do
10360     if test -n "$ncn_target_tool_prefix"; then
10361       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10362 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10363 echo "$as_me:$LINENO: checking for $ac_word" >&5
10364 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10365 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10366   echo $ECHO_N "(cached) $ECHO_C" >&6
10367 else
10368   if test -n "$LD_FOR_TARGET"; then
10369   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10370 else
10371 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10372 for as_dir in $PATH
10373 do
10374   IFS=$as_save_IFS
10375   test -z "$as_dir" && as_dir=.
10376   for ac_exec_ext in '' $ac_executable_extensions; do
10377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10378     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10380     break 2
10381   fi
10382 done
10383 done
10384
10385 fi
10386 fi
10387 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10388 if test -n "$LD_FOR_TARGET"; then
10389   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10390 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10391 else
10392   echo "$as_me:$LINENO: result: no" >&5
10393 echo "${ECHO_T}no" >&6
10394 fi
10395
10396     fi
10397     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10398       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10399 set dummy ${ncn_progname}; ac_word=$2
10400 echo "$as_me:$LINENO: checking for $ac_word" >&5
10401 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10402 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10403   echo $ECHO_N "(cached) $ECHO_C" >&6
10404 else
10405   if test -n "$LD_FOR_TARGET"; then
10406   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10407 else
10408 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10409 for as_dir in $PATH
10410 do
10411   IFS=$as_save_IFS
10412   test -z "$as_dir" && as_dir=.
10413   for ac_exec_ext in '' $ac_executable_extensions; do
10414   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10415     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10416     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10417     break 2
10418   fi
10419 done
10420 done
10421
10422 fi
10423 fi
10424 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10425 if test -n "$LD_FOR_TARGET"; then
10426   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10427 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10428 else
10429   echo "$as_me:$LINENO: result: no" >&5
10430 echo "${ECHO_T}no" >&6
10431 fi
10432
10433     fi
10434     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10435   done
10436 fi
10437
10438 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10439   set dummy ld
10440   if test $build = $target ; then
10441     LD_FOR_TARGET="$2"
10442   else
10443     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10444   fi
10445 else
10446   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10447 fi
10448
10449 else
10450   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10451 fi
10452
10453
10454
10455
10456 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10457   if test -n "$with_build_time_tools"; then
10458     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10459 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10460     if test -x $with_build_time_tools/lipo; then
10461       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10462       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10463       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10464 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10465     else
10466       echo "$as_me:$LINENO: result: no" >&5
10467 echo "${ECHO_T}no" >&6
10468     fi
10469   elif test $build != $host && test $have_gcc_for_target = yes; then
10470     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10471     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10472     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10473   fi
10474 fi
10475 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10476   # Extract the first word of "lipo", so it can be a program name with args.
10477 set dummy lipo; ac_word=$2
10478 echo "$as_me:$LINENO: checking for $ac_word" >&5
10479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10480 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10481   echo $ECHO_N "(cached) $ECHO_C" >&6
10482 else
10483   case $LIPO_FOR_TARGET in
10484   [\\/]* | ?:[\\/]*)
10485   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10486   ;;
10487   *)
10488   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10489 for as_dir in $gcc_cv_tool_dirs
10490 do
10491   IFS=$as_save_IFS
10492   test -z "$as_dir" && as_dir=.
10493   for ac_exec_ext in '' $ac_executable_extensions; do
10494   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10495     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10496     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10497     break 2
10498   fi
10499 done
10500 done
10501
10502   ;;
10503 esac
10504 fi
10505 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10506
10507 if test -n "$LIPO_FOR_TARGET"; then
10508   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10509 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10510 else
10511   echo "$as_me:$LINENO: result: no" >&5
10512 echo "${ECHO_T}no" >&6
10513 fi
10514
10515 fi
10516 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10517
10518
10519 if test -n "$LIPO_FOR_TARGET"; then
10520   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10521 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10522   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10523 fi
10524
10525 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10526   for ncn_progname in lipo; do
10527     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10528 set dummy ${ncn_progname}; ac_word=$2
10529 echo "$as_me:$LINENO: checking for $ac_word" >&5
10530 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10531 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10532   echo $ECHO_N "(cached) $ECHO_C" >&6
10533 else
10534   if test -n "$LIPO_FOR_TARGET"; then
10535   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10536 else
10537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10538 for as_dir in $PATH
10539 do
10540   IFS=$as_save_IFS
10541   test -z "$as_dir" && as_dir=.
10542   for ac_exec_ext in '' $ac_executable_extensions; do
10543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10544     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10546     break 2
10547   fi
10548 done
10549 done
10550
10551 fi
10552 fi
10553 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10554 if test -n "$LIPO_FOR_TARGET"; then
10555   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10556 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10557 else
10558   echo "$as_me:$LINENO: result: no" >&5
10559 echo "${ECHO_T}no" >&6
10560 fi
10561
10562   done
10563 fi
10564
10565 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10566   for ncn_progname in lipo; do
10567     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10568 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10569     if test -x $with_build_time_tools/${ncn_progname}; then
10570       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10571       echo "$as_me:$LINENO: result: yes" >&5
10572 echo "${ECHO_T}yes" >&6
10573       break
10574     else
10575       echo "$as_me:$LINENO: result: no" >&5
10576 echo "${ECHO_T}no" >&6
10577     fi
10578   done
10579 fi
10580
10581 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10582   for ncn_progname in lipo; do
10583     if test -n "$ncn_target_tool_prefix"; then
10584       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10585 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10586 echo "$as_me:$LINENO: checking for $ac_word" >&5
10587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10588 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10589   echo $ECHO_N "(cached) $ECHO_C" >&6
10590 else
10591   if test -n "$LIPO_FOR_TARGET"; then
10592   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10593 else
10594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10595 for as_dir in $PATH
10596 do
10597   IFS=$as_save_IFS
10598   test -z "$as_dir" && as_dir=.
10599   for ac_exec_ext in '' $ac_executable_extensions; do
10600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10601     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10603     break 2
10604   fi
10605 done
10606 done
10607
10608 fi
10609 fi
10610 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10611 if test -n "$LIPO_FOR_TARGET"; then
10612   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10613 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10614 else
10615   echo "$as_me:$LINENO: result: no" >&5
10616 echo "${ECHO_T}no" >&6
10617 fi
10618
10619     fi
10620     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10621       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10622 set dummy ${ncn_progname}; ac_word=$2
10623 echo "$as_me:$LINENO: checking for $ac_word" >&5
10624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10625 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10626   echo $ECHO_N "(cached) $ECHO_C" >&6
10627 else
10628   if test -n "$LIPO_FOR_TARGET"; then
10629   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10630 else
10631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10632 for as_dir in $PATH
10633 do
10634   IFS=$as_save_IFS
10635   test -z "$as_dir" && as_dir=.
10636   for ac_exec_ext in '' $ac_executable_extensions; do
10637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10638     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10640     break 2
10641   fi
10642 done
10643 done
10644
10645 fi
10646 fi
10647 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10648 if test -n "$LIPO_FOR_TARGET"; then
10649   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10650 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10651 else
10652   echo "$as_me:$LINENO: result: no" >&5
10653 echo "${ECHO_T}no" >&6
10654 fi
10655
10656     fi
10657     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10658   done
10659 fi
10660
10661 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10662   set dummy lipo
10663   if test $build = $target ; then
10664     LIPO_FOR_TARGET="$2"
10665   else
10666     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10667   fi
10668 else
10669   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10670 fi
10671
10672 else
10673   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10674 fi
10675
10676
10677
10678
10679 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10680   if test -n "$with_build_time_tools"; then
10681     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10682 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10683     if test -x $with_build_time_tools/nm; then
10684       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10685       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10686       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10687 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10688     else
10689       echo "$as_me:$LINENO: result: no" >&5
10690 echo "${ECHO_T}no" >&6
10691     fi
10692   elif test $build != $host && test $have_gcc_for_target = yes; then
10693     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10694     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10695     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10696   fi
10697 fi
10698 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10699   # Extract the first word of "nm", so it can be a program name with args.
10700 set dummy nm; ac_word=$2
10701 echo "$as_me:$LINENO: checking for $ac_word" >&5
10702 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10703 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10704   echo $ECHO_N "(cached) $ECHO_C" >&6
10705 else
10706   case $NM_FOR_TARGET in
10707   [\\/]* | ?:[\\/]*)
10708   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10709   ;;
10710   *)
10711   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10712 for as_dir in $gcc_cv_tool_dirs
10713 do
10714   IFS=$as_save_IFS
10715   test -z "$as_dir" && as_dir=.
10716   for ac_exec_ext in '' $ac_executable_extensions; do
10717   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10718     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10719     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10720     break 2
10721   fi
10722 done
10723 done
10724
10725   ;;
10726 esac
10727 fi
10728 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10729
10730 if test -n "$NM_FOR_TARGET"; then
10731   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10732 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10733 else
10734   echo "$as_me:$LINENO: result: no" >&5
10735 echo "${ECHO_T}no" >&6
10736 fi
10737
10738 fi
10739 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10740
10741
10742 if test -n "$NM_FOR_TARGET"; then
10743   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10744 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10745   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10746 fi
10747
10748 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10749   for ncn_progname in nm; do
10750     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10751 set dummy ${ncn_progname}; ac_word=$2
10752 echo "$as_me:$LINENO: checking for $ac_word" >&5
10753 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10754 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10755   echo $ECHO_N "(cached) $ECHO_C" >&6
10756 else
10757   if test -n "$NM_FOR_TARGET"; then
10758   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10759 else
10760 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10761 for as_dir in $PATH
10762 do
10763   IFS=$as_save_IFS
10764   test -z "$as_dir" && as_dir=.
10765   for ac_exec_ext in '' $ac_executable_extensions; do
10766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10767     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10769     break 2
10770   fi
10771 done
10772 done
10773
10774 fi
10775 fi
10776 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10777 if test -n "$NM_FOR_TARGET"; then
10778   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10779 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10780 else
10781   echo "$as_me:$LINENO: result: no" >&5
10782 echo "${ECHO_T}no" >&6
10783 fi
10784
10785   done
10786 fi
10787
10788 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10789   for ncn_progname in nm; do
10790     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10791 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10792     if test -x $with_build_time_tools/${ncn_progname}; then
10793       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10794       echo "$as_me:$LINENO: result: yes" >&5
10795 echo "${ECHO_T}yes" >&6
10796       break
10797     else
10798       echo "$as_me:$LINENO: result: no" >&5
10799 echo "${ECHO_T}no" >&6
10800     fi
10801   done
10802 fi
10803
10804 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10805   for ncn_progname in nm; do
10806     if test -n "$ncn_target_tool_prefix"; then
10807       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10808 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10809 echo "$as_me:$LINENO: checking for $ac_word" >&5
10810 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10811 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10812   echo $ECHO_N "(cached) $ECHO_C" >&6
10813 else
10814   if test -n "$NM_FOR_TARGET"; then
10815   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10816 else
10817 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10818 for as_dir in $PATH
10819 do
10820   IFS=$as_save_IFS
10821   test -z "$as_dir" && as_dir=.
10822   for ac_exec_ext in '' $ac_executable_extensions; do
10823   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10824     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10825     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10826     break 2
10827   fi
10828 done
10829 done
10830
10831 fi
10832 fi
10833 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10834 if test -n "$NM_FOR_TARGET"; then
10835   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10836 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10837 else
10838   echo "$as_me:$LINENO: result: no" >&5
10839 echo "${ECHO_T}no" >&6
10840 fi
10841
10842     fi
10843     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10844       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10845 set dummy ${ncn_progname}; ac_word=$2
10846 echo "$as_me:$LINENO: checking for $ac_word" >&5
10847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10848 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10849   echo $ECHO_N "(cached) $ECHO_C" >&6
10850 else
10851   if test -n "$NM_FOR_TARGET"; then
10852   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10853 else
10854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10855 for as_dir in $PATH
10856 do
10857   IFS=$as_save_IFS
10858   test -z "$as_dir" && as_dir=.
10859   for ac_exec_ext in '' $ac_executable_extensions; do
10860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10861     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10863     break 2
10864   fi
10865 done
10866 done
10867
10868 fi
10869 fi
10870 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10871 if test -n "$NM_FOR_TARGET"; then
10872   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10873 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10874 else
10875   echo "$as_me:$LINENO: result: no" >&5
10876 echo "${ECHO_T}no" >&6
10877 fi
10878
10879     fi
10880     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10881   done
10882 fi
10883
10884 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10885   set dummy nm
10886   if test $build = $target ; then
10887     NM_FOR_TARGET="$2"
10888   else
10889     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10890   fi
10891 else
10892   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10893 fi
10894
10895 else
10896   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10897 fi
10898
10899
10900
10901
10902 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10903   if test -n "$with_build_time_tools"; then
10904     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10905 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10906     if test -x $with_build_time_tools/objdump; then
10907       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10908       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10909       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10910 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10911     else
10912       echo "$as_me:$LINENO: result: no" >&5
10913 echo "${ECHO_T}no" >&6
10914     fi
10915   elif test $build != $host && test $have_gcc_for_target = yes; then
10916     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10917     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10918     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10919   fi
10920 fi
10921 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10922   # Extract the first word of "objdump", so it can be a program name with args.
10923 set dummy objdump; ac_word=$2
10924 echo "$as_me:$LINENO: checking for $ac_word" >&5
10925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10926 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10927   echo $ECHO_N "(cached) $ECHO_C" >&6
10928 else
10929   case $OBJDUMP_FOR_TARGET in
10930   [\\/]* | ?:[\\/]*)
10931   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10932   ;;
10933   *)
10934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10935 for as_dir in $gcc_cv_tool_dirs
10936 do
10937   IFS=$as_save_IFS
10938   test -z "$as_dir" && as_dir=.
10939   for ac_exec_ext in '' $ac_executable_extensions; do
10940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10941     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10943     break 2
10944   fi
10945 done
10946 done
10947
10948   ;;
10949 esac
10950 fi
10951 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10952
10953 if test -n "$OBJDUMP_FOR_TARGET"; then
10954   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10955 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10956 else
10957   echo "$as_me:$LINENO: result: no" >&5
10958 echo "${ECHO_T}no" >&6
10959 fi
10960
10961 fi
10962 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10963
10964
10965 if test -n "$OBJDUMP_FOR_TARGET"; then
10966   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10967 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10968   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10969 fi
10970
10971 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10972   for ncn_progname in objdump; do
10973     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10974 set dummy ${ncn_progname}; ac_word=$2
10975 echo "$as_me:$LINENO: checking for $ac_word" >&5
10976 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10977 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10978   echo $ECHO_N "(cached) $ECHO_C" >&6
10979 else
10980   if test -n "$OBJDUMP_FOR_TARGET"; then
10981   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10982 else
10983 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10984 for as_dir in $PATH
10985 do
10986   IFS=$as_save_IFS
10987   test -z "$as_dir" && as_dir=.
10988   for ac_exec_ext in '' $ac_executable_extensions; do
10989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10990     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10992     break 2
10993   fi
10994 done
10995 done
10996
10997 fi
10998 fi
10999 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11000 if test -n "$OBJDUMP_FOR_TARGET"; then
11001   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11002 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11003 else
11004   echo "$as_me:$LINENO: result: no" >&5
11005 echo "${ECHO_T}no" >&6
11006 fi
11007
11008   done
11009 fi
11010
11011 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11012   for ncn_progname in objdump; do
11013     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11014 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11015     if test -x $with_build_time_tools/${ncn_progname}; then
11016       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11017       echo "$as_me:$LINENO: result: yes" >&5
11018 echo "${ECHO_T}yes" >&6
11019       break
11020     else
11021       echo "$as_me:$LINENO: result: no" >&5
11022 echo "${ECHO_T}no" >&6
11023     fi
11024   done
11025 fi
11026
11027 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
11028   for ncn_progname in objdump; do
11029     if test -n "$ncn_target_tool_prefix"; then
11030       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11031 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11032 echo "$as_me:$LINENO: checking for $ac_word" >&5
11033 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11034 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11035   echo $ECHO_N "(cached) $ECHO_C" >&6
11036 else
11037   if test -n "$OBJDUMP_FOR_TARGET"; then
11038   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11039 else
11040 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11041 for as_dir in $PATH
11042 do
11043   IFS=$as_save_IFS
11044   test -z "$as_dir" && as_dir=.
11045   for ac_exec_ext in '' $ac_executable_extensions; do
11046   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11047     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11048     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11049     break 2
11050   fi
11051 done
11052 done
11053
11054 fi
11055 fi
11056 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11057 if test -n "$OBJDUMP_FOR_TARGET"; then
11058   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11059 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11060 else
11061   echo "$as_me:$LINENO: result: no" >&5
11062 echo "${ECHO_T}no" >&6
11063 fi
11064
11065     fi
11066     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
11067       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11068 set dummy ${ncn_progname}; ac_word=$2
11069 echo "$as_me:$LINENO: checking for $ac_word" >&5
11070 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11071 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
11072   echo $ECHO_N "(cached) $ECHO_C" >&6
11073 else
11074   if test -n "$OBJDUMP_FOR_TARGET"; then
11075   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
11076 else
11077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11078 for as_dir in $PATH
11079 do
11080   IFS=$as_save_IFS
11081   test -z "$as_dir" && as_dir=.
11082   for ac_exec_ext in '' $ac_executable_extensions; do
11083   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11084     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
11085     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11086     break 2
11087   fi
11088 done
11089 done
11090
11091 fi
11092 fi
11093 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
11094 if test -n "$OBJDUMP_FOR_TARGET"; then
11095   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
11096 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
11097 else
11098   echo "$as_me:$LINENO: result: no" >&5
11099 echo "${ECHO_T}no" >&6
11100 fi
11101
11102     fi
11103     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
11104   done
11105 fi
11106
11107 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11108   set dummy objdump
11109   if test $build = $target ; then
11110     OBJDUMP_FOR_TARGET="$2"
11111   else
11112     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11113   fi
11114 else
11115   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11116 fi
11117
11118 else
11119   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11120 fi
11121
11122
11123
11124
11125 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11126   if test -n "$with_build_time_tools"; then
11127     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11128 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11129     if test -x $with_build_time_tools/ranlib; then
11130       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11131       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11132       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11133 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11134     else
11135       echo "$as_me:$LINENO: result: no" >&5
11136 echo "${ECHO_T}no" >&6
11137     fi
11138   elif test $build != $host && test $have_gcc_for_target = yes; then
11139     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11140     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11141     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11142   fi
11143 fi
11144 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11145   # Extract the first word of "ranlib", so it can be a program name with args.
11146 set dummy ranlib; ac_word=$2
11147 echo "$as_me:$LINENO: checking for $ac_word" >&5
11148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11149 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11150   echo $ECHO_N "(cached) $ECHO_C" >&6
11151 else
11152   case $RANLIB_FOR_TARGET in
11153   [\\/]* | ?:[\\/]*)
11154   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11155   ;;
11156   *)
11157   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11158 for as_dir in $gcc_cv_tool_dirs
11159 do
11160   IFS=$as_save_IFS
11161   test -z "$as_dir" && as_dir=.
11162   for ac_exec_ext in '' $ac_executable_extensions; do
11163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11164     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11166     break 2
11167   fi
11168 done
11169 done
11170
11171   ;;
11172 esac
11173 fi
11174 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11175
11176 if test -n "$RANLIB_FOR_TARGET"; then
11177   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11178 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11179 else
11180   echo "$as_me:$LINENO: result: no" >&5
11181 echo "${ECHO_T}no" >&6
11182 fi
11183
11184 fi
11185 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11186
11187
11188 if test -n "$RANLIB_FOR_TARGET"; then
11189   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11190 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11191   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11192 fi
11193
11194 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11195   for ncn_progname in ranlib; do
11196     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11197 set dummy ${ncn_progname}; ac_word=$2
11198 echo "$as_me:$LINENO: checking for $ac_word" >&5
11199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11200 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11201   echo $ECHO_N "(cached) $ECHO_C" >&6
11202 else
11203   if test -n "$RANLIB_FOR_TARGET"; then
11204   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11205 else
11206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11207 for as_dir in $PATH
11208 do
11209   IFS=$as_save_IFS
11210   test -z "$as_dir" && as_dir=.
11211   for ac_exec_ext in '' $ac_executable_extensions; do
11212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11213     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11215     break 2
11216   fi
11217 done
11218 done
11219
11220 fi
11221 fi
11222 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11223 if test -n "$RANLIB_FOR_TARGET"; then
11224   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11225 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11226 else
11227   echo "$as_me:$LINENO: result: no" >&5
11228 echo "${ECHO_T}no" >&6
11229 fi
11230
11231   done
11232 fi
11233
11234 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11235   for ncn_progname in ranlib; do
11236     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11237 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11238     if test -x $with_build_time_tools/${ncn_progname}; then
11239       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11240       echo "$as_me:$LINENO: result: yes" >&5
11241 echo "${ECHO_T}yes" >&6
11242       break
11243     else
11244       echo "$as_me:$LINENO: result: no" >&5
11245 echo "${ECHO_T}no" >&6
11246     fi
11247   done
11248 fi
11249
11250 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11251   for ncn_progname in ranlib; do
11252     if test -n "$ncn_target_tool_prefix"; then
11253       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11254 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11255 echo "$as_me:$LINENO: checking for $ac_word" >&5
11256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11257 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11258   echo $ECHO_N "(cached) $ECHO_C" >&6
11259 else
11260   if test -n "$RANLIB_FOR_TARGET"; then
11261   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11262 else
11263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11264 for as_dir in $PATH
11265 do
11266   IFS=$as_save_IFS
11267   test -z "$as_dir" && as_dir=.
11268   for ac_exec_ext in '' $ac_executable_extensions; do
11269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11270     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11272     break 2
11273   fi
11274 done
11275 done
11276
11277 fi
11278 fi
11279 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11280 if test -n "$RANLIB_FOR_TARGET"; then
11281   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11282 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11283 else
11284   echo "$as_me:$LINENO: result: no" >&5
11285 echo "${ECHO_T}no" >&6
11286 fi
11287
11288     fi
11289     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11290       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11291 set dummy ${ncn_progname}; ac_word=$2
11292 echo "$as_me:$LINENO: checking for $ac_word" >&5
11293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11294 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11295   echo $ECHO_N "(cached) $ECHO_C" >&6
11296 else
11297   if test -n "$RANLIB_FOR_TARGET"; then
11298   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11299 else
11300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11301 for as_dir in $PATH
11302 do
11303   IFS=$as_save_IFS
11304   test -z "$as_dir" && as_dir=.
11305   for ac_exec_ext in '' $ac_executable_extensions; do
11306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11307     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11309     break 2
11310   fi
11311 done
11312 done
11313
11314 fi
11315 fi
11316 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11317 if test -n "$RANLIB_FOR_TARGET"; then
11318   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11319 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11320 else
11321   echo "$as_me:$LINENO: result: no" >&5
11322 echo "${ECHO_T}no" >&6
11323 fi
11324
11325     fi
11326     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11327   done
11328 fi
11329
11330 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11331   set dummy ranlib
11332   if test $build = $target ; then
11333     RANLIB_FOR_TARGET="$2"
11334   else
11335     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11336   fi
11337 else
11338   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11339 fi
11340
11341 else
11342   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11343 fi
11344
11345
11346
11347
11348 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11349   if test -n "$with_build_time_tools"; then
11350     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11351 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11352     if test -x $with_build_time_tools/strip; then
11353       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11354       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11355       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11356 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11357     else
11358       echo "$as_me:$LINENO: result: no" >&5
11359 echo "${ECHO_T}no" >&6
11360     fi
11361   elif test $build != $host && test $have_gcc_for_target = yes; then
11362     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11363     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11364     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11365   fi
11366 fi
11367 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11368   # Extract the first word of "strip", so it can be a program name with args.
11369 set dummy strip; ac_word=$2
11370 echo "$as_me:$LINENO: checking for $ac_word" >&5
11371 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11372 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11373   echo $ECHO_N "(cached) $ECHO_C" >&6
11374 else
11375   case $STRIP_FOR_TARGET in
11376   [\\/]* | ?:[\\/]*)
11377   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11378   ;;
11379   *)
11380   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11381 for as_dir in $gcc_cv_tool_dirs
11382 do
11383   IFS=$as_save_IFS
11384   test -z "$as_dir" && as_dir=.
11385   for ac_exec_ext in '' $ac_executable_extensions; do
11386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11387     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11389     break 2
11390   fi
11391 done
11392 done
11393
11394   ;;
11395 esac
11396 fi
11397 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11398
11399 if test -n "$STRIP_FOR_TARGET"; then
11400   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11401 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11402 else
11403   echo "$as_me:$LINENO: result: no" >&5
11404 echo "${ECHO_T}no" >&6
11405 fi
11406
11407 fi
11408 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11409
11410
11411 if test -n "$STRIP_FOR_TARGET"; then
11412   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11413 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11414   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11415 fi
11416
11417 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11418   for ncn_progname in strip; do
11419     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11420 set dummy ${ncn_progname}; ac_word=$2
11421 echo "$as_me:$LINENO: checking for $ac_word" >&5
11422 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11423 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11424   echo $ECHO_N "(cached) $ECHO_C" >&6
11425 else
11426   if test -n "$STRIP_FOR_TARGET"; then
11427   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11428 else
11429 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11430 for as_dir in $PATH
11431 do
11432   IFS=$as_save_IFS
11433   test -z "$as_dir" && as_dir=.
11434   for ac_exec_ext in '' $ac_executable_extensions; do
11435   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11436     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11437     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11438     break 2
11439   fi
11440 done
11441 done
11442
11443 fi
11444 fi
11445 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11446 if test -n "$STRIP_FOR_TARGET"; then
11447   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11448 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11449 else
11450   echo "$as_me:$LINENO: result: no" >&5
11451 echo "${ECHO_T}no" >&6
11452 fi
11453
11454   done
11455 fi
11456
11457 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11458   for ncn_progname in strip; do
11459     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11460 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11461     if test -x $with_build_time_tools/${ncn_progname}; then
11462       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11463       echo "$as_me:$LINENO: result: yes" >&5
11464 echo "${ECHO_T}yes" >&6
11465       break
11466     else
11467       echo "$as_me:$LINENO: result: no" >&5
11468 echo "${ECHO_T}no" >&6
11469     fi
11470   done
11471 fi
11472
11473 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11474   for ncn_progname in strip; do
11475     if test -n "$ncn_target_tool_prefix"; then
11476       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11477 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11478 echo "$as_me:$LINENO: checking for $ac_word" >&5
11479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11480 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11481   echo $ECHO_N "(cached) $ECHO_C" >&6
11482 else
11483   if test -n "$STRIP_FOR_TARGET"; then
11484   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11485 else
11486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11487 for as_dir in $PATH
11488 do
11489   IFS=$as_save_IFS
11490   test -z "$as_dir" && as_dir=.
11491   for ac_exec_ext in '' $ac_executable_extensions; do
11492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11493     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11495     break 2
11496   fi
11497 done
11498 done
11499
11500 fi
11501 fi
11502 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11503 if test -n "$STRIP_FOR_TARGET"; then
11504   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11505 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11506 else
11507   echo "$as_me:$LINENO: result: no" >&5
11508 echo "${ECHO_T}no" >&6
11509 fi
11510
11511     fi
11512     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11513       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11514 set dummy ${ncn_progname}; ac_word=$2
11515 echo "$as_me:$LINENO: checking for $ac_word" >&5
11516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11517 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11518   echo $ECHO_N "(cached) $ECHO_C" >&6
11519 else
11520   if test -n "$STRIP_FOR_TARGET"; then
11521   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11522 else
11523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11524 for as_dir in $PATH
11525 do
11526   IFS=$as_save_IFS
11527   test -z "$as_dir" && as_dir=.
11528   for ac_exec_ext in '' $ac_executable_extensions; do
11529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11530     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11532     break 2
11533   fi
11534 done
11535 done
11536
11537 fi
11538 fi
11539 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11540 if test -n "$STRIP_FOR_TARGET"; then
11541   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11542 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11543 else
11544   echo "$as_me:$LINENO: result: no" >&5
11545 echo "${ECHO_T}no" >&6
11546 fi
11547
11548     fi
11549     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11550   done
11551 fi
11552
11553 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11554   set dummy strip
11555   if test $build = $target ; then
11556     STRIP_FOR_TARGET="$2"
11557   else
11558     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11559   fi
11560 else
11561   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11562 fi
11563
11564 else
11565   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11566 fi
11567
11568
11569
11570
11571 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11572   if test -n "$with_build_time_tools"; then
11573     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11574 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11575     if test -x $with_build_time_tools/windres; then
11576       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11577       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11578       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11579 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11580     else
11581       echo "$as_me:$LINENO: result: no" >&5
11582 echo "${ECHO_T}no" >&6
11583     fi
11584   elif test $build != $host && test $have_gcc_for_target = yes; then
11585     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11586     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11587     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11588   fi
11589 fi
11590 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11591   # Extract the first word of "windres", so it can be a program name with args.
11592 set dummy windres; ac_word=$2
11593 echo "$as_me:$LINENO: checking for $ac_word" >&5
11594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11595 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11596   echo $ECHO_N "(cached) $ECHO_C" >&6
11597 else
11598   case $WINDRES_FOR_TARGET in
11599   [\\/]* | ?:[\\/]*)
11600   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11601   ;;
11602   *)
11603   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11604 for as_dir in $gcc_cv_tool_dirs
11605 do
11606   IFS=$as_save_IFS
11607   test -z "$as_dir" && as_dir=.
11608   for ac_exec_ext in '' $ac_executable_extensions; do
11609   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11610     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11611     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11612     break 2
11613   fi
11614 done
11615 done
11616
11617   ;;
11618 esac
11619 fi
11620 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11621
11622 if test -n "$WINDRES_FOR_TARGET"; then
11623   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11624 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11625 else
11626   echo "$as_me:$LINENO: result: no" >&5
11627 echo "${ECHO_T}no" >&6
11628 fi
11629
11630 fi
11631 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11632
11633
11634 if test -n "$WINDRES_FOR_TARGET"; then
11635   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11636 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11637   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11638 fi
11639
11640 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11641   for ncn_progname in windres; do
11642     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11643 set dummy ${ncn_progname}; ac_word=$2
11644 echo "$as_me:$LINENO: checking for $ac_word" >&5
11645 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11646 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11647   echo $ECHO_N "(cached) $ECHO_C" >&6
11648 else
11649   if test -n "$WINDRES_FOR_TARGET"; then
11650   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11651 else
11652 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11653 for as_dir in $PATH
11654 do
11655   IFS=$as_save_IFS
11656   test -z "$as_dir" && as_dir=.
11657   for ac_exec_ext in '' $ac_executable_extensions; do
11658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11659     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11661     break 2
11662   fi
11663 done
11664 done
11665
11666 fi
11667 fi
11668 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11669 if test -n "$WINDRES_FOR_TARGET"; then
11670   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11671 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11672 else
11673   echo "$as_me:$LINENO: result: no" >&5
11674 echo "${ECHO_T}no" >&6
11675 fi
11676
11677   done
11678 fi
11679
11680 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11681   for ncn_progname in windres; do
11682     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11683 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11684     if test -x $with_build_time_tools/${ncn_progname}; then
11685       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11686       echo "$as_me:$LINENO: result: yes" >&5
11687 echo "${ECHO_T}yes" >&6
11688       break
11689     else
11690       echo "$as_me:$LINENO: result: no" >&5
11691 echo "${ECHO_T}no" >&6
11692     fi
11693   done
11694 fi
11695
11696 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11697   for ncn_progname in windres; do
11698     if test -n "$ncn_target_tool_prefix"; then
11699       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11700 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11701 echo "$as_me:$LINENO: checking for $ac_word" >&5
11702 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11703 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11704   echo $ECHO_N "(cached) $ECHO_C" >&6
11705 else
11706   if test -n "$WINDRES_FOR_TARGET"; then
11707   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11708 else
11709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11710 for as_dir in $PATH
11711 do
11712   IFS=$as_save_IFS
11713   test -z "$as_dir" && as_dir=.
11714   for ac_exec_ext in '' $ac_executable_extensions; do
11715   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11716     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11717     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11718     break 2
11719   fi
11720 done
11721 done
11722
11723 fi
11724 fi
11725 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11726 if test -n "$WINDRES_FOR_TARGET"; then
11727   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11728 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11729 else
11730   echo "$as_me:$LINENO: result: no" >&5
11731 echo "${ECHO_T}no" >&6
11732 fi
11733
11734     fi
11735     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11736       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11737 set dummy ${ncn_progname}; ac_word=$2
11738 echo "$as_me:$LINENO: checking for $ac_word" >&5
11739 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11740 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11741   echo $ECHO_N "(cached) $ECHO_C" >&6
11742 else
11743   if test -n "$WINDRES_FOR_TARGET"; then
11744   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11745 else
11746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11747 for as_dir in $PATH
11748 do
11749   IFS=$as_save_IFS
11750   test -z "$as_dir" && as_dir=.
11751   for ac_exec_ext in '' $ac_executable_extensions; do
11752   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11753     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11754     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11755     break 2
11756   fi
11757 done
11758 done
11759
11760 fi
11761 fi
11762 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11763 if test -n "$WINDRES_FOR_TARGET"; then
11764   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11765 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11766 else
11767   echo "$as_me:$LINENO: result: no" >&5
11768 echo "${ECHO_T}no" >&6
11769 fi
11770
11771     fi
11772     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11773   done
11774 fi
11775
11776 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11777   set dummy windres
11778   if test $build = $target ; then
11779     WINDRES_FOR_TARGET="$2"
11780   else
11781     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11782   fi
11783 else
11784   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11785 fi
11786
11787 else
11788   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11789 fi
11790
11791
11792
11793
11794 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11795   if test -n "$with_build_time_tools"; then
11796     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11797 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11798     if test -x $with_build_time_tools/windmc; then
11799       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11800       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11801       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11802 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11803     else
11804       echo "$as_me:$LINENO: result: no" >&5
11805 echo "${ECHO_T}no" >&6
11806     fi
11807   elif test $build != $host && test $have_gcc_for_target = yes; then
11808     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11809     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11810     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11811   fi
11812 fi
11813 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11814   # Extract the first word of "windmc", so it can be a program name with args.
11815 set dummy windmc; ac_word=$2
11816 echo "$as_me:$LINENO: checking for $ac_word" >&5
11817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11818 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11819   echo $ECHO_N "(cached) $ECHO_C" >&6
11820 else
11821   case $WINDMC_FOR_TARGET in
11822   [\\/]* | ?:[\\/]*)
11823   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11824   ;;
11825   *)
11826   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11827 for as_dir in $gcc_cv_tool_dirs
11828 do
11829   IFS=$as_save_IFS
11830   test -z "$as_dir" && as_dir=.
11831   for ac_exec_ext in '' $ac_executable_extensions; do
11832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11833     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11835     break 2
11836   fi
11837 done
11838 done
11839
11840   ;;
11841 esac
11842 fi
11843 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11844
11845 if test -n "$WINDMC_FOR_TARGET"; then
11846   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11847 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11848 else
11849   echo "$as_me:$LINENO: result: no" >&5
11850 echo "${ECHO_T}no" >&6
11851 fi
11852
11853 fi
11854 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11855
11856
11857 if test -n "$WINDMC_FOR_TARGET"; then
11858   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11859 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11860   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11861 fi
11862
11863 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11864   for ncn_progname in windmc; do
11865     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11866 set dummy ${ncn_progname}; ac_word=$2
11867 echo "$as_me:$LINENO: checking for $ac_word" >&5
11868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11869 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11870   echo $ECHO_N "(cached) $ECHO_C" >&6
11871 else
11872   if test -n "$WINDMC_FOR_TARGET"; then
11873   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11874 else
11875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11876 for as_dir in $PATH
11877 do
11878   IFS=$as_save_IFS
11879   test -z "$as_dir" && as_dir=.
11880   for ac_exec_ext in '' $ac_executable_extensions; do
11881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11882     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11884     break 2
11885   fi
11886 done
11887 done
11888
11889 fi
11890 fi
11891 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11892 if test -n "$WINDMC_FOR_TARGET"; then
11893   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11894 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11895 else
11896   echo "$as_me:$LINENO: result: no" >&5
11897 echo "${ECHO_T}no" >&6
11898 fi
11899
11900   done
11901 fi
11902
11903 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11904   for ncn_progname in windmc; do
11905     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11906 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11907     if test -x $with_build_time_tools/${ncn_progname}; then
11908       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11909       echo "$as_me:$LINENO: result: yes" >&5
11910 echo "${ECHO_T}yes" >&6
11911       break
11912     else
11913       echo "$as_me:$LINENO: result: no" >&5
11914 echo "${ECHO_T}no" >&6
11915     fi
11916   done
11917 fi
11918
11919 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11920   for ncn_progname in windmc; do
11921     if test -n "$ncn_target_tool_prefix"; then
11922       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11923 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11924 echo "$as_me:$LINENO: checking for $ac_word" >&5
11925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11926 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11927   echo $ECHO_N "(cached) $ECHO_C" >&6
11928 else
11929   if test -n "$WINDMC_FOR_TARGET"; then
11930   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11931 else
11932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11933 for as_dir in $PATH
11934 do
11935   IFS=$as_save_IFS
11936   test -z "$as_dir" && as_dir=.
11937   for ac_exec_ext in '' $ac_executable_extensions; do
11938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11939     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11941     break 2
11942   fi
11943 done
11944 done
11945
11946 fi
11947 fi
11948 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11949 if test -n "$WINDMC_FOR_TARGET"; then
11950   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11951 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11952 else
11953   echo "$as_me:$LINENO: result: no" >&5
11954 echo "${ECHO_T}no" >&6
11955 fi
11956
11957     fi
11958     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11959       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11960 set dummy ${ncn_progname}; ac_word=$2
11961 echo "$as_me:$LINENO: checking for $ac_word" >&5
11962 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11963 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11964   echo $ECHO_N "(cached) $ECHO_C" >&6
11965 else
11966   if test -n "$WINDMC_FOR_TARGET"; then
11967   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11968 else
11969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11970 for as_dir in $PATH
11971 do
11972   IFS=$as_save_IFS
11973   test -z "$as_dir" && as_dir=.
11974   for ac_exec_ext in '' $ac_executable_extensions; do
11975   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11976     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11977     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11978     break 2
11979   fi
11980 done
11981 done
11982
11983 fi
11984 fi
11985 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11986 if test -n "$WINDMC_FOR_TARGET"; then
11987   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11988 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11989 else
11990   echo "$as_me:$LINENO: result: no" >&5
11991 echo "${ECHO_T}no" >&6
11992 fi
11993
11994     fi
11995     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11996   done
11997 fi
11998
11999 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
12000   set dummy windmc
12001   if test $build = $target ; then
12002     WINDMC_FOR_TARGET="$2"
12003   else
12004     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
12005   fi
12006 else
12007   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
12008 fi
12009
12010 else
12011   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
12012 fi
12013
12014
12015 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
12016
12017 echo "$as_me:$LINENO: checking where to find the target ar" >&5
12018 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
12019 if test "x${build}" != "x${host}" ; then
12020   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12021     # We already found the complete path
12022     ac_dir=`dirname $AR_FOR_TARGET`
12023     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12024 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12025   else
12026     # Canadian cross, just use what we found
12027     echo "$as_me:$LINENO: result: pre-installed" >&5
12028 echo "${ECHO_T}pre-installed" >&6
12029   fi
12030 else
12031   ok=yes
12032   case " ${configdirs} " in
12033     *" binutils "*) ;;
12034     *) ok=no ;;
12035   esac
12036
12037   if test $ok = yes; then
12038     # An in-tree tool is available and we can use it
12039     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
12040     echo "$as_me:$LINENO: result: just compiled" >&5
12041 echo "${ECHO_T}just compiled" >&6
12042   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
12043     # We already found the complete path
12044     ac_dir=`dirname $AR_FOR_TARGET`
12045     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12046 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12047   elif test "x$target" = "x$host"; then
12048     # We can use an host tool
12049     AR_FOR_TARGET='$(AR)'
12050     echo "$as_me:$LINENO: result: host tool" >&5
12051 echo "${ECHO_T}host tool" >&6
12052   else
12053     # We need a cross tool
12054     echo "$as_me:$LINENO: result: pre-installed" >&5
12055 echo "${ECHO_T}pre-installed" >&6
12056   fi
12057 fi
12058
12059 echo "$as_me:$LINENO: checking where to find the target as" >&5
12060 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
12061 if test "x${build}" != "x${host}" ; then
12062   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12063     # We already found the complete path
12064     ac_dir=`dirname $AS_FOR_TARGET`
12065     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12066 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12067   else
12068     # Canadian cross, just use what we found
12069     echo "$as_me:$LINENO: result: pre-installed" >&5
12070 echo "${ECHO_T}pre-installed" >&6
12071   fi
12072 else
12073   ok=yes
12074   case " ${configdirs} " in
12075     *" gas "*) ;;
12076     *) ok=no ;;
12077   esac
12078
12079   if test $ok = yes; then
12080     # An in-tree tool is available and we can use it
12081     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
12082     echo "$as_me:$LINENO: result: just compiled" >&5
12083 echo "${ECHO_T}just compiled" >&6
12084   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
12085     # We already found the complete path
12086     ac_dir=`dirname $AS_FOR_TARGET`
12087     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12088 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12089   elif test "x$target" = "x$host"; then
12090     # We can use an host tool
12091     AS_FOR_TARGET='$(AS)'
12092     echo "$as_me:$LINENO: result: host tool" >&5
12093 echo "${ECHO_T}host tool" >&6
12094   else
12095     # We need a cross tool
12096     echo "$as_me:$LINENO: result: pre-installed" >&5
12097 echo "${ECHO_T}pre-installed" >&6
12098   fi
12099 fi
12100
12101 echo "$as_me:$LINENO: checking where to find the target cc" >&5
12102 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
12103 if test "x${build}" != "x${host}" ; then
12104   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12105     # We already found the complete path
12106     ac_dir=`dirname $CC_FOR_TARGET`
12107     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12108 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12109   else
12110     # Canadian cross, just use what we found
12111     echo "$as_me:$LINENO: result: pre-installed" >&5
12112 echo "${ECHO_T}pre-installed" >&6
12113   fi
12114 else
12115   ok=yes
12116   case " ${configdirs} " in
12117     *" gcc "*) ;;
12118     *) ok=no ;;
12119   esac
12120
12121   if test $ok = yes; then
12122     # An in-tree tool is available and we can use it
12123     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12124     echo "$as_me:$LINENO: result: just compiled" >&5
12125 echo "${ECHO_T}just compiled" >&6
12126   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12127     # We already found the complete path
12128     ac_dir=`dirname $CC_FOR_TARGET`
12129     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12130 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12131   elif test "x$target" = "x$host"; then
12132     # We can use an host tool
12133     CC_FOR_TARGET='$(CC)'
12134     echo "$as_me:$LINENO: result: host tool" >&5
12135 echo "${ECHO_T}host tool" >&6
12136   else
12137     # We need a cross tool
12138     echo "$as_me:$LINENO: result: pre-installed" >&5
12139 echo "${ECHO_T}pre-installed" >&6
12140   fi
12141 fi
12142
12143 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12144 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12145 if test "x${build}" != "x${host}" ; then
12146   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12147     # We already found the complete path
12148     ac_dir=`dirname $CXX_FOR_TARGET`
12149     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12150 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12151   else
12152     # Canadian cross, just use what we found
12153     echo "$as_me:$LINENO: result: pre-installed" >&5
12154 echo "${ECHO_T}pre-installed" >&6
12155   fi
12156 else
12157   ok=yes
12158   case " ${configdirs} " in
12159     *" gcc "*) ;;
12160     *) ok=no ;;
12161   esac
12162   case ,${enable_languages}, in
12163     *,c++,*) ;;
12164     *) ok=no ;;
12165   esac
12166   if test $ok = yes; then
12167     # An in-tree tool is available and we can use it
12168     CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/g++ -B$$r/$(HOST_SUBDIR)/gcc/ -nostdinc++ `test ! -f $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags || $(SHELL) $$r/$(TARGET_SUBDIR)/libstdc++-v3/scripts/testsuite_flags --build-includes` -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
12169     echo "$as_me:$LINENO: result: just compiled" >&5
12170 echo "${ECHO_T}just compiled" >&6
12171   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12172     # We already found the complete path
12173     ac_dir=`dirname $CXX_FOR_TARGET`
12174     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12175 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12176   elif test "x$target" = "x$host"; then
12177     # We can use an host tool
12178     CXX_FOR_TARGET='$(CXX)'
12179     echo "$as_me:$LINENO: result: host tool" >&5
12180 echo "${ECHO_T}host tool" >&6
12181   else
12182     # We need a cross tool
12183     echo "$as_me:$LINENO: result: pre-installed" >&5
12184 echo "${ECHO_T}pre-installed" >&6
12185   fi
12186 fi
12187
12188 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12189 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12190 if test "x${build}" != "x${host}" ; then
12191   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12192     # We already found the complete path
12193     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12194     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12195 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12196   else
12197     # Canadian cross, just use what we found
12198     echo "$as_me:$LINENO: result: pre-installed" >&5
12199 echo "${ECHO_T}pre-installed" >&6
12200   fi
12201 else
12202   ok=yes
12203   case " ${configdirs} " in
12204     *" gcc "*) ;;
12205     *) ok=no ;;
12206   esac
12207   case ,${enable_languages}, in
12208     *,c++,*) ;;
12209     *) ok=no ;;
12210   esac
12211   if test $ok = yes; then
12212     # An in-tree tool is available and we can use it
12213     RAW_CXX_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -shared-libgcc -B$$r/$(HOST_SUBDIR)/gcc -nostdinc++ -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src -L$$r/$(TARGET_SUBDIR)/libstdc++-v3/src/.libs'
12214     echo "$as_me:$LINENO: result: just compiled" >&5
12215 echo "${ECHO_T}just compiled" >&6
12216   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12217     # We already found the complete path
12218     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12219     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12220 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12221   elif test "x$target" = "x$host"; then
12222     # We can use an host tool
12223     RAW_CXX_FOR_TARGET='$(CXX)'
12224     echo "$as_me:$LINENO: result: host tool" >&5
12225 echo "${ECHO_T}host tool" >&6
12226   else
12227     # We need a cross tool
12228     echo "$as_me:$LINENO: result: pre-installed" >&5
12229 echo "${ECHO_T}pre-installed" >&6
12230   fi
12231 fi
12232
12233 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12234 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12235 if test "x${build}" != "x${host}" ; then
12236   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12237     # We already found the complete path
12238     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12239     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12240 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12241   else
12242     # Canadian cross, just use what we found
12243     echo "$as_me:$LINENO: result: pre-installed" >&5
12244 echo "${ECHO_T}pre-installed" >&6
12245   fi
12246 else
12247   ok=yes
12248   case " ${configdirs} " in
12249     *" binutils "*) ;;
12250     *) ok=no ;;
12251   esac
12252
12253   if test $ok = yes; then
12254     # An in-tree tool is available and we can use it
12255     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12256     echo "$as_me:$LINENO: result: just compiled" >&5
12257 echo "${ECHO_T}just compiled" >&6
12258   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12259     # We already found the complete path
12260     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12261     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12262 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12263   elif test "x$target" = "x$host"; then
12264     # We can use an host tool
12265     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12266     echo "$as_me:$LINENO: result: host tool" >&5
12267 echo "${ECHO_T}host tool" >&6
12268   else
12269     # We need a cross tool
12270     echo "$as_me:$LINENO: result: pre-installed" >&5
12271 echo "${ECHO_T}pre-installed" >&6
12272   fi
12273 fi
12274
12275 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12276 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12277 if test "x${build}" != "x${host}" ; then
12278   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12279     # We already found the complete path
12280     ac_dir=`dirname $GCC_FOR_TARGET`
12281     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12282 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12283   else
12284     # Canadian cross, just use what we found
12285     echo "$as_me:$LINENO: result: pre-installed" >&5
12286 echo "${ECHO_T}pre-installed" >&6
12287   fi
12288 else
12289   ok=yes
12290   case " ${configdirs} " in
12291     *" gcc "*) ;;
12292     *) ok=no ;;
12293   esac
12294
12295   if test $ok = yes; then
12296     # An in-tree tool is available and we can use it
12297     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12298     echo "$as_me:$LINENO: result: just compiled" >&5
12299 echo "${ECHO_T}just compiled" >&6
12300   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12301     # We already found the complete path
12302     ac_dir=`dirname $GCC_FOR_TARGET`
12303     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12304 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12305   elif test "x$target" = "x$host"; then
12306     # We can use an host tool
12307     GCC_FOR_TARGET='$()'
12308     echo "$as_me:$LINENO: result: host tool" >&5
12309 echo "${ECHO_T}host tool" >&6
12310   else
12311     # We need a cross tool
12312     echo "$as_me:$LINENO: result: pre-installed" >&5
12313 echo "${ECHO_T}pre-installed" >&6
12314   fi
12315 fi
12316
12317 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12318 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12319 if test "x${build}" != "x${host}" ; then
12320   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12321     # We already found the complete path
12322     ac_dir=`dirname $GCJ_FOR_TARGET`
12323     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12324 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12325   else
12326     # Canadian cross, just use what we found
12327     echo "$as_me:$LINENO: result: pre-installed" >&5
12328 echo "${ECHO_T}pre-installed" >&6
12329   fi
12330 else
12331   ok=yes
12332   case " ${configdirs} " in
12333     *" gcc "*) ;;
12334     *) ok=no ;;
12335   esac
12336   case ,${enable_languages}, in
12337     *,java,*) ;;
12338     *) ok=no ;;
12339   esac
12340   if test $ok = yes; then
12341     # An in-tree tool is available and we can use it
12342     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12343     echo "$as_me:$LINENO: result: just compiled" >&5
12344 echo "${ECHO_T}just compiled" >&6
12345   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12346     # We already found the complete path
12347     ac_dir=`dirname $GCJ_FOR_TARGET`
12348     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12349 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12350   elif test "x$target" = "x$host"; then
12351     # We can use an host tool
12352     GCJ_FOR_TARGET='$(GCJ)'
12353     echo "$as_me:$LINENO: result: host tool" >&5
12354 echo "${ECHO_T}host tool" >&6
12355   else
12356     # We need a cross tool
12357     echo "$as_me:$LINENO: result: pre-installed" >&5
12358 echo "${ECHO_T}pre-installed" >&6
12359   fi
12360 fi
12361
12362 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12363 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12364 if test "x${build}" != "x${host}" ; then
12365   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12366     # We already found the complete path
12367     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12368     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12369 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12370   else
12371     # Canadian cross, just use what we found
12372     echo "$as_me:$LINENO: result: pre-installed" >&5
12373 echo "${ECHO_T}pre-installed" >&6
12374   fi
12375 else
12376   ok=yes
12377   case " ${configdirs} " in
12378     *" gcc "*) ;;
12379     *) ok=no ;;
12380   esac
12381   case ,${enable_languages}, in
12382     *,fortran,*) ;;
12383     *) ok=no ;;
12384   esac
12385   if test $ok = yes; then
12386     # An in-tree tool is available and we can use it
12387     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12388     echo "$as_me:$LINENO: result: just compiled" >&5
12389 echo "${ECHO_T}just compiled" >&6
12390   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12391     # We already found the complete path
12392     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12393     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12394 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12395   elif test "x$target" = "x$host"; then
12396     # We can use an host tool
12397     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12398     echo "$as_me:$LINENO: result: host tool" >&5
12399 echo "${ECHO_T}host tool" >&6
12400   else
12401     # We need a cross tool
12402     echo "$as_me:$LINENO: result: pre-installed" >&5
12403 echo "${ECHO_T}pre-installed" >&6
12404   fi
12405 fi
12406
12407 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12408 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12409 if test "x${build}" != "x${host}" ; then
12410   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12411     # We already found the complete path
12412     ac_dir=`dirname $LD_FOR_TARGET`
12413     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12414 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12415   else
12416     # Canadian cross, just use what we found
12417     echo "$as_me:$LINENO: result: pre-installed" >&5
12418 echo "${ECHO_T}pre-installed" >&6
12419   fi
12420 else
12421   ok=yes
12422   case " ${configdirs} " in
12423     *" ld "*) ;;
12424     *) ok=no ;;
12425   esac
12426
12427   if test $ok = yes; then
12428     # An in-tree tool is available and we can use it
12429     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12430     echo "$as_me:$LINENO: result: just compiled" >&5
12431 echo "${ECHO_T}just compiled" >&6
12432   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12433     # We already found the complete path
12434     ac_dir=`dirname $LD_FOR_TARGET`
12435     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12436 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12437   elif test "x$target" = "x$host"; then
12438     # We can use an host tool
12439     LD_FOR_TARGET='$(LD)'
12440     echo "$as_me:$LINENO: result: host tool" >&5
12441 echo "${ECHO_T}host tool" >&6
12442   else
12443     # We need a cross tool
12444     echo "$as_me:$LINENO: result: pre-installed" >&5
12445 echo "${ECHO_T}pre-installed" >&6
12446   fi
12447 fi
12448
12449 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12450 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12451 if test "x${build}" != "x${host}" ; then
12452   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12453     # We already found the complete path
12454     ac_dir=`dirname $LIPO_FOR_TARGET`
12455     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12456 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12457   else
12458     # Canadian cross, just use what we found
12459     echo "$as_me:$LINENO: result: pre-installed" >&5
12460 echo "${ECHO_T}pre-installed" >&6
12461   fi
12462 else
12463   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12464     # We already found the complete path
12465     ac_dir=`dirname $LIPO_FOR_TARGET`
12466     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12467 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12468   elif test "x$target" = "x$host"; then
12469     # We can use an host tool
12470     LIPO_FOR_TARGET='$(LIPO)'
12471     echo "$as_me:$LINENO: result: host tool" >&5
12472 echo "${ECHO_T}host tool" >&6
12473   else
12474     # We need a cross tool
12475     echo "$as_me:$LINENO: result: pre-installed" >&5
12476 echo "${ECHO_T}pre-installed" >&6
12477   fi
12478 fi
12479
12480 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12481 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12482 if test "x${build}" != "x${host}" ; then
12483   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12484     # We already found the complete path
12485     ac_dir=`dirname $NM_FOR_TARGET`
12486     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12487 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12488   else
12489     # Canadian cross, just use what we found
12490     echo "$as_me:$LINENO: result: pre-installed" >&5
12491 echo "${ECHO_T}pre-installed" >&6
12492   fi
12493 else
12494   ok=yes
12495   case " ${configdirs} " in
12496     *" binutils "*) ;;
12497     *) ok=no ;;
12498   esac
12499
12500   if test $ok = yes; then
12501     # An in-tree tool is available and we can use it
12502     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12503     echo "$as_me:$LINENO: result: just compiled" >&5
12504 echo "${ECHO_T}just compiled" >&6
12505   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12506     # We already found the complete path
12507     ac_dir=`dirname $NM_FOR_TARGET`
12508     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12509 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12510   elif test "x$target" = "x$host"; then
12511     # We can use an host tool
12512     NM_FOR_TARGET='$(NM)'
12513     echo "$as_me:$LINENO: result: host tool" >&5
12514 echo "${ECHO_T}host tool" >&6
12515   else
12516     # We need a cross tool
12517     echo "$as_me:$LINENO: result: pre-installed" >&5
12518 echo "${ECHO_T}pre-installed" >&6
12519   fi
12520 fi
12521
12522 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12523 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12524 if test "x${build}" != "x${host}" ; then
12525   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12526     # We already found the complete path
12527     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12528     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12529 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12530   else
12531     # Canadian cross, just use what we found
12532     echo "$as_me:$LINENO: result: pre-installed" >&5
12533 echo "${ECHO_T}pre-installed" >&6
12534   fi
12535 else
12536   ok=yes
12537   case " ${configdirs} " in
12538     *" binutils "*) ;;
12539     *) ok=no ;;
12540   esac
12541
12542   if test $ok = yes; then
12543     # An in-tree tool is available and we can use it
12544     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12545     echo "$as_me:$LINENO: result: just compiled" >&5
12546 echo "${ECHO_T}just compiled" >&6
12547   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12548     # We already found the complete path
12549     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12550     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12551 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12552   elif test "x$target" = "x$host"; then
12553     # We can use an host tool
12554     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12555     echo "$as_me:$LINENO: result: host tool" >&5
12556 echo "${ECHO_T}host tool" >&6
12557   else
12558     # We need a cross tool
12559     echo "$as_me:$LINENO: result: pre-installed" >&5
12560 echo "${ECHO_T}pre-installed" >&6
12561   fi
12562 fi
12563
12564 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12565 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12566 if test "x${build}" != "x${host}" ; then
12567   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12568     # We already found the complete path
12569     ac_dir=`dirname $RANLIB_FOR_TARGET`
12570     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12571 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12572   else
12573     # Canadian cross, just use what we found
12574     echo "$as_me:$LINENO: result: pre-installed" >&5
12575 echo "${ECHO_T}pre-installed" >&6
12576   fi
12577 else
12578   ok=yes
12579   case " ${configdirs} " in
12580     *" binutils "*) ;;
12581     *) ok=no ;;
12582   esac
12583
12584   if test $ok = yes; then
12585     # An in-tree tool is available and we can use it
12586     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12587     echo "$as_me:$LINENO: result: just compiled" >&5
12588 echo "${ECHO_T}just compiled" >&6
12589   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12590     # We already found the complete path
12591     ac_dir=`dirname $RANLIB_FOR_TARGET`
12592     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12593 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12594   elif test "x$target" = "x$host"; then
12595     # We can use an host tool
12596     RANLIB_FOR_TARGET='$(RANLIB)'
12597     echo "$as_me:$LINENO: result: host tool" >&5
12598 echo "${ECHO_T}host tool" >&6
12599   else
12600     # We need a cross tool
12601     echo "$as_me:$LINENO: result: pre-installed" >&5
12602 echo "${ECHO_T}pre-installed" >&6
12603   fi
12604 fi
12605
12606 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12607 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12608 if test "x${build}" != "x${host}" ; then
12609   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12610     # We already found the complete path
12611     ac_dir=`dirname $STRIP_FOR_TARGET`
12612     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12613 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12614   else
12615     # Canadian cross, just use what we found
12616     echo "$as_me:$LINENO: result: pre-installed" >&5
12617 echo "${ECHO_T}pre-installed" >&6
12618   fi
12619 else
12620   ok=yes
12621   case " ${configdirs} " in
12622     *" binutils "*) ;;
12623     *) ok=no ;;
12624   esac
12625
12626   if test $ok = yes; then
12627     # An in-tree tool is available and we can use it
12628     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12629     echo "$as_me:$LINENO: result: just compiled" >&5
12630 echo "${ECHO_T}just compiled" >&6
12631   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12632     # We already found the complete path
12633     ac_dir=`dirname $STRIP_FOR_TARGET`
12634     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12635 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12636   elif test "x$target" = "x$host"; then
12637     # We can use an host tool
12638     STRIP_FOR_TARGET='$(STRIP)'
12639     echo "$as_me:$LINENO: result: host tool" >&5
12640 echo "${ECHO_T}host tool" >&6
12641   else
12642     # We need a cross tool
12643     echo "$as_me:$LINENO: result: pre-installed" >&5
12644 echo "${ECHO_T}pre-installed" >&6
12645   fi
12646 fi
12647
12648 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12649 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12650 if test "x${build}" != "x${host}" ; then
12651   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12652     # We already found the complete path
12653     ac_dir=`dirname $WINDRES_FOR_TARGET`
12654     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12655 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12656   else
12657     # Canadian cross, just use what we found
12658     echo "$as_me:$LINENO: result: pre-installed" >&5
12659 echo "${ECHO_T}pre-installed" >&6
12660   fi
12661 else
12662   ok=yes
12663   case " ${configdirs} " in
12664     *" binutils "*) ;;
12665     *) ok=no ;;
12666   esac
12667
12668   if test $ok = yes; then
12669     # An in-tree tool is available and we can use it
12670     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12671     echo "$as_me:$LINENO: result: just compiled" >&5
12672 echo "${ECHO_T}just compiled" >&6
12673   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12674     # We already found the complete path
12675     ac_dir=`dirname $WINDRES_FOR_TARGET`
12676     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12677 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12678   elif test "x$target" = "x$host"; then
12679     # We can use an host tool
12680     WINDRES_FOR_TARGET='$(WINDRES)'
12681     echo "$as_me:$LINENO: result: host tool" >&5
12682 echo "${ECHO_T}host tool" >&6
12683   else
12684     # We need a cross tool
12685     echo "$as_me:$LINENO: result: pre-installed" >&5
12686 echo "${ECHO_T}pre-installed" >&6
12687   fi
12688 fi
12689
12690 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12691 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12692 if test "x${build}" != "x${host}" ; then
12693   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12694     # We already found the complete path
12695     ac_dir=`dirname $WINDMC_FOR_TARGET`
12696     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12697 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12698   else
12699     # Canadian cross, just use what we found
12700     echo "$as_me:$LINENO: result: pre-installed" >&5
12701 echo "${ECHO_T}pre-installed" >&6
12702   fi
12703 else
12704   ok=yes
12705   case " ${configdirs} " in
12706     *" binutils "*) ;;
12707     *) ok=no ;;
12708   esac
12709
12710   if test $ok = yes; then
12711     # An in-tree tool is available and we can use it
12712     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12713     echo "$as_me:$LINENO: result: just compiled" >&5
12714 echo "${ECHO_T}just compiled" >&6
12715   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12716     # We already found the complete path
12717     ac_dir=`dirname $WINDMC_FOR_TARGET`
12718     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12719 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12720   elif test "x$target" = "x$host"; then
12721     # We can use an host tool
12722     WINDMC_FOR_TARGET='$(WINDMC)'
12723     echo "$as_me:$LINENO: result: host tool" >&5
12724 echo "${ECHO_T}host tool" >&6
12725   else
12726     # We need a cross tool
12727     echo "$as_me:$LINENO: result: pre-installed" >&5
12728 echo "${ECHO_T}pre-installed" >&6
12729   fi
12730 fi
12731
12732
12733
12734
12735
12736 # Certain tools may need extra flags.
12737 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12738 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12739 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12740
12741 # When building target libraries, except in a Canadian cross, we use
12742 # the same toolchain as the compiler we just built.
12743 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12744 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12745 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12746 if test $host = $build; then
12747   case " $configdirs " in
12748     *" gcc "*)
12749       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12750       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12751       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12752       ;;
12753   esac
12754 fi
12755
12756
12757
12758
12759
12760 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12761 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12762 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12763 if test "${enable_maintainer_mode+set}" = set; then
12764   enableval="$enable_maintainer_mode"
12765   USE_MAINTAINER_MODE=$enableval
12766 else
12767   USE_MAINTAINER_MODE=no
12768 fi;
12769 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12770 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12771
12772
12773 if test "$USE_MAINTAINER_MODE" = yes; then
12774   MAINTAINER_MODE_TRUE=
12775   MAINTAINER_MODE_FALSE='#'
12776 else
12777   MAINTAINER_MODE_TRUE='#'
12778   MAINTAINER_MODE_FALSE=
12779 fi
12780 MAINT=$MAINTAINER_MODE_TRUE
12781
12782 # ---------------------
12783 # GCC bootstrap support
12784 # ---------------------
12785
12786 # Stage specific cflags for build.
12787 stage1_cflags="-g"
12788 case $build in
12789   vax-*-*)
12790     case ${GCC} in
12791       yes) stage1_cflags="-g -Wa,-J" ;;
12792       *) stage1_cflags="-g -J" ;;
12793     esac ;;
12794 esac
12795
12796 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12797 if test "$GCC" = yes -a "$ENABLE_BUILD_WITH_CXX" != yes; then
12798   saved_CFLAGS="$CFLAGS"
12799
12800   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12801   CFLAGS="$CFLAGS -fkeep-inline-functions"
12802   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12803 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12804   cat >conftest.$ac_ext <<_ACEOF
12805 /* confdefs.h.  */
12806 _ACEOF
12807 cat confdefs.h >>conftest.$ac_ext
12808 cat >>conftest.$ac_ext <<_ACEOF
12809 /* end confdefs.h.  */
12810
12811 #if (__GNUC__ < 3) \
12812     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12813                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12814 #error http://gcc.gnu.org/PR29382
12815 #endif
12816
12817 int
12818 main ()
12819 {
12820
12821   ;
12822   return 0;
12823 }
12824 _ACEOF
12825 rm -f conftest.$ac_objext
12826 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12827   (eval $ac_compile) 2>conftest.er1
12828   ac_status=$?
12829   grep -v '^ *+' conftest.er1 >conftest.err
12830   rm -f conftest.er1
12831   cat conftest.err >&5
12832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12833   (exit $ac_status); } &&
12834          { ac_try='test -z "$ac_c_werror_flag"
12835                          || test ! -s conftest.err'
12836   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12837   (eval $ac_try) 2>&5
12838   ac_status=$?
12839   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12840   (exit $ac_status); }; } &&
12841          { ac_try='test -s conftest.$ac_objext'
12842   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12843   (eval $ac_try) 2>&5
12844   ac_status=$?
12845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12846   (exit $ac_status); }; }; then
12847   echo "$as_me:$LINENO: result: yes" >&5
12848 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12849 else
12850   echo "$as_me: failed program was:" >&5
12851 sed 's/^/| /' conftest.$ac_ext >&5
12852
12853 echo "$as_me:$LINENO: result: no" >&5
12854 echo "${ECHO_T}no" >&6
12855 fi
12856 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12857
12858   CFLAGS="$saved_CFLAGS"
12859 fi
12860
12861
12862
12863 # Enable --enable-checking in stage1 of the compiler.
12864 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12865 if test "${enable_stage1_checking+set}" = set; then
12866   enableval="$enable_stage1_checking"
12867   stage1_checking=--enable-checking=${enable_stage1_checking}
12868 else
12869   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12870   stage1_checking=--enable-checking=yes,types
12871 else
12872   stage1_checking=--enable-checking=$enable_checking,types
12873 fi
12874 fi;
12875
12876
12877 # Enable -Werror in bootstrap stage2 and later.
12878 # Check whether --enable-werror or --disable-werror was given.
12879 if test "${enable_werror+set}" = set; then
12880   enableval="$enable_werror"
12881
12882 else
12883   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12884   enable_werror=yes
12885 else
12886   enable_werror=no
12887 fi
12888 fi;
12889 case ${enable_werror} in
12890   yes) stage2_werror_flag="--enable-werror-always" ;;
12891   *) stage2_werror_flag="" ;;
12892 esac
12893
12894
12895 # Flags needed to enable html installing and building
12896
12897 # Check whether --with-datarootdir or --without-datarootdir was given.
12898 if test "${with_datarootdir+set}" = set; then
12899   withval="$with_datarootdir"
12900   datarootdir="\${prefix}/${withval}"
12901 else
12902   datarootdir="\${prefix}/share"
12903 fi;
12904
12905
12906 # Check whether --with-docdir or --without-docdir was given.
12907 if test "${with_docdir+set}" = set; then
12908   withval="$with_docdir"
12909   docdir="\${prefix}/${withval}"
12910 else
12911   docdir="\${datarootdir}/doc"
12912 fi;
12913
12914
12915 # Check whether --with-pdfdir or --without-pdfdir was given.
12916 if test "${with_pdfdir+set}" = set; then
12917   withval="$with_pdfdir"
12918   pdfdir="\${prefix}/${withval}"
12919 else
12920   pdfdir="\${docdir}"
12921 fi;
12922
12923
12924 # Check whether --with-htmldir or --without-htmldir was given.
12925 if test "${with_htmldir+set}" = set; then
12926   withval="$with_htmldir"
12927   htmldir="\${prefix}/${withval}"
12928 else
12929   htmldir="\${docdir}"
12930 fi;
12931
12932
12933
12934
12935
12936
12937 # Specify what files to not compare during bootstrap.
12938
12939 compare_exclusions="gcc/cc*-checksum\$(objext) | gcc/ada/*tools/*"
12940 case "$target" in
12941   hppa*64*-*-hpux*) ;;
12942   hppa*-*-hpux*) compare_exclusions="gcc/cc*-checksum\$(objext) | */libgcc/lib2funcs* | gcc/ada/*tools/*" ;;
12943 esac
12944
12945
12946           ac_config_files="$ac_config_files Makefile"
12947 cat >confcache <<\_ACEOF
12948 # This file is a shell script that caches the results of configure
12949 # tests run on this system so they can be shared between configure
12950 # scripts and configure runs, see configure's option --config-cache.
12951 # It is not useful on other systems.  If it contains results you don't
12952 # want to keep, you may remove or edit it.
12953 #
12954 # config.status only pays attention to the cache file if you give it
12955 # the --recheck option to rerun configure.
12956 #
12957 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12958 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12959 # following values.
12960
12961 _ACEOF
12962
12963 # The following way of writing the cache mishandles newlines in values,
12964 # but we know of no workaround that is simple, portable, and efficient.
12965 # So, don't put newlines in cache variables' values.
12966 # Ultrix sh set writes to stderr and can't be redirected directly,
12967 # and sets the high bit in the cache file unless we assign to the vars.
12968 {
12969   (set) 2>&1 |
12970     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12971     *ac_space=\ *)
12972       # `set' does not quote correctly, so add quotes (double-quote
12973       # substitution turns \\\\ into \\, and sed turns \\ into \).
12974       sed -n \
12975         "s/'/'\\\\''/g;
12976           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12977       ;;
12978     *)
12979       # `set' quotes correctly as required by POSIX, so do not add quotes.
12980       sed -n \
12981         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12982       ;;
12983     esac;
12984 } |
12985   sed '
12986      t clear
12987      : clear
12988      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12989      t end
12990      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12991      : end' >>confcache
12992 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12993   if test -w $cache_file; then
12994     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12995     cat confcache >$cache_file
12996   else
12997     echo "not updating unwritable cache $cache_file"
12998   fi
12999 fi
13000 rm -f confcache
13001
13002 test "x$prefix" = xNONE && prefix=$ac_default_prefix
13003 # Let make expand exec_prefix.
13004 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
13005
13006 # VPATH may cause trouble with some makes, so we remove $(srcdir),
13007 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
13008 # trailing colons and then remove the whole line if VPATH becomes empty
13009 # (actually we leave an empty line to preserve line numbers).
13010 if test "x$srcdir" = x.; then
13011   ac_vpsub='/^[  ]*VPATH[        ]*=/{
13012 s/:*\$(srcdir):*/:/;
13013 s/:*\${srcdir}:*/:/;
13014 s/:*@srcdir@:*/:/;
13015 s/^\([^=]*=[     ]*\):*/\1/;
13016 s/:*$//;
13017 s/^[^=]*=[       ]*$//;
13018 }'
13019 fi
13020
13021 # Transform confdefs.h into DEFS.
13022 # Protect against shell expansion while executing Makefile rules.
13023 # Protect against Makefile macro expansion.
13024 #
13025 # If the first sed substitution is executed (which looks for macros that
13026 # take arguments), then we branch to the quote section.  Otherwise,
13027 # look for a macro that doesn't take arguments.
13028 cat >confdef2opt.sed <<\_ACEOF
13029 t clear
13030 : clear
13031 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
13032 t quote
13033 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
13034 t quote
13035 d
13036 : quote
13037 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
13038 s,\[,\\&,g
13039 s,\],\\&,g
13040 s,\$,$$,g
13041 p
13042 _ACEOF
13043 # We use echo to avoid assuming a particular line-breaking character.
13044 # The extra dot is to prevent the shell from consuming trailing
13045 # line-breaks from the sub-command output.  A line-break within
13046 # single-quotes doesn't work because, if this script is created in a
13047 # platform that uses two characters for line-breaks (e.g., DOS), tr
13048 # would break.
13049 ac_LF_and_DOT=`echo; echo .`
13050 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
13051 rm -f confdef2opt.sed
13052
13053
13054 ac_libobjs=
13055 ac_ltlibobjs=
13056 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
13057   # 1. Remove the extension, and $U if already installed.
13058   ac_i=`echo "$ac_i" |
13059          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
13060   # 2. Add them.
13061   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
13062   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
13063 done
13064 LIBOBJS=$ac_libobjs
13065
13066 LTLIBOBJS=$ac_ltlibobjs
13067
13068
13069
13070 : ${CONFIG_STATUS=./config.status}
13071 ac_clean_files_save=$ac_clean_files
13072 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
13073 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
13074 echo "$as_me: creating $CONFIG_STATUS" >&6;}
13075 cat >$CONFIG_STATUS <<_ACEOF
13076 #! $SHELL
13077 # Generated by $as_me.
13078 # Run this file to recreate the current configuration.
13079 # Compiler output produced by configure, useful for debugging
13080 # configure, is in config.log if it exists.
13081
13082 debug=false
13083 ac_cs_recheck=false
13084 ac_cs_silent=false
13085 SHELL=\${CONFIG_SHELL-$SHELL}
13086 _ACEOF
13087
13088 cat >>$CONFIG_STATUS <<\_ACEOF
13089 ## --------------------- ##
13090 ## M4sh Initialization.  ##
13091 ## --------------------- ##
13092
13093 # Be Bourne compatible
13094 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
13095   emulate sh
13096   NULLCMD=:
13097   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
13098   # is contrary to our usage.  Disable this feature.
13099   alias -g '${1+"$@"}'='"$@"'
13100 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
13101   set -o posix
13102 fi
13103 DUALCASE=1; export DUALCASE # for MKS sh
13104
13105 # Support unset when possible.
13106 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
13107   as_unset=unset
13108 else
13109   as_unset=false
13110 fi
13111
13112
13113 # Work around bugs in pre-3.0 UWIN ksh.
13114 $as_unset ENV MAIL MAILPATH
13115 PS1='$ '
13116 PS2='> '
13117 PS4='+ '
13118
13119 # NLS nuisances.
13120 for as_var in \
13121   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13122   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13123   LC_TELEPHONE LC_TIME
13124 do
13125   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13126     eval $as_var=C; export $as_var
13127   else
13128     $as_unset $as_var
13129   fi
13130 done
13131
13132 # Required to use basename.
13133 if expr a : '\(a\)' >/dev/null 2>&1; then
13134   as_expr=expr
13135 else
13136   as_expr=false
13137 fi
13138
13139 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13140   as_basename=basename
13141 else
13142   as_basename=false
13143 fi
13144
13145
13146 # Name of the executable.
13147 as_me=`$as_basename "$0" ||
13148 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13149          X"$0" : 'X\(//\)$' \| \
13150          X"$0" : 'X\(/\)$' \| \
13151          .     : '\(.\)' 2>/dev/null ||
13152 echo X/"$0" |
13153     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13154           /^X\/\(\/\/\)$/{ s//\1/; q; }
13155           /^X\/\(\/\).*/{ s//\1/; q; }
13156           s/.*/./; q'`
13157
13158
13159 # PATH needs CR, and LINENO needs CR and PATH.
13160 # Avoid depending upon Character Ranges.
13161 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13162 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13163 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13164 as_cr_digits='0123456789'
13165 as_cr_alnum=$as_cr_Letters$as_cr_digits
13166
13167 # The user is always right.
13168 if test "${PATH_SEPARATOR+set}" != set; then
13169   echo "#! /bin/sh" >conf$$.sh
13170   echo  "exit 0"   >>conf$$.sh
13171   chmod +x conf$$.sh
13172   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13173     PATH_SEPARATOR=';'
13174   else
13175     PATH_SEPARATOR=:
13176   fi
13177   rm -f conf$$.sh
13178 fi
13179
13180
13181   as_lineno_1=$LINENO
13182   as_lineno_2=$LINENO
13183   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13184   test "x$as_lineno_1" != "x$as_lineno_2" &&
13185   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13186   # Find who we are.  Look in the path if we contain no path at all
13187   # relative or not.
13188   case $0 in
13189     *[\\/]* ) as_myself=$0 ;;
13190     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13191 for as_dir in $PATH
13192 do
13193   IFS=$as_save_IFS
13194   test -z "$as_dir" && as_dir=.
13195   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13196 done
13197
13198        ;;
13199   esac
13200   # We did not find ourselves, most probably we were run as `sh COMMAND'
13201   # in which case we are not to be found in the path.
13202   if test "x$as_myself" = x; then
13203     as_myself=$0
13204   fi
13205   if test ! -f "$as_myself"; then
13206     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13207 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13208    { (exit 1); exit 1; }; }
13209   fi
13210   case $CONFIG_SHELL in
13211   '')
13212     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13213 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13214 do
13215   IFS=$as_save_IFS
13216   test -z "$as_dir" && as_dir=.
13217   for as_base in sh bash ksh sh5; do
13218          case $as_dir in
13219          /*)
13220            if ("$as_dir/$as_base" -c '
13221   as_lineno_1=$LINENO
13222   as_lineno_2=$LINENO
13223   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13224   test "x$as_lineno_1" != "x$as_lineno_2" &&
13225   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13226              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13227              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13228              CONFIG_SHELL=$as_dir/$as_base
13229              export CONFIG_SHELL
13230              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13231            fi;;
13232          esac
13233        done
13234 done
13235 ;;
13236   esac
13237
13238   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13239   # uniformly replaced by the line number.  The first 'sed' inserts a
13240   # line-number line before each line; the second 'sed' does the real
13241   # work.  The second script uses 'N' to pair each line-number line
13242   # with the numbered line, and appends trailing '-' during
13243   # substitution so that $LINENO is not a special case at line end.
13244   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13245   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13246   sed '=' <$as_myself |
13247     sed '
13248       N
13249       s,$,-,
13250       : loop
13251       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13252       t loop
13253       s,-$,,
13254       s,^['$as_cr_digits']*\n,,
13255     ' >$as_me.lineno &&
13256   chmod +x $as_me.lineno ||
13257     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13258 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13259    { (exit 1); exit 1; }; }
13260
13261   # Don't try to exec as it changes $[0], causing all sort of problems
13262   # (the dirname of $[0] is not the place where we might find the
13263   # original and so on.  Autoconf is especially sensible to this).
13264   . ./$as_me.lineno
13265   # Exit status is that of the last command.
13266   exit
13267 }
13268
13269
13270 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13271   *c*,-n*) ECHO_N= ECHO_C='
13272 ' ECHO_T='      ' ;;
13273   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13274   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13275 esac
13276
13277 if expr a : '\(a\)' >/dev/null 2>&1; then
13278   as_expr=expr
13279 else
13280   as_expr=false
13281 fi
13282
13283 rm -f conf$$ conf$$.exe conf$$.file
13284 echo >conf$$.file
13285 if ln -s conf$$.file conf$$ 2>/dev/null; then
13286   # We could just check for DJGPP; but this test a) works b) is more generic
13287   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13288   if test -f conf$$.exe; then
13289     # Don't use ln at all; we don't have any links
13290     as_ln_s='cp -p'
13291   else
13292     as_ln_s='ln -s'
13293   fi
13294 elif ln conf$$.file conf$$ 2>/dev/null; then
13295   as_ln_s=ln
13296 else
13297   as_ln_s='cp -p'
13298 fi
13299 rm -f conf$$ conf$$.exe conf$$.file
13300
13301 if mkdir -p . 2>/dev/null; then
13302   as_mkdir_p=:
13303 else
13304   test -d ./-p && rmdir ./-p
13305   as_mkdir_p=false
13306 fi
13307
13308 as_executable_p="test -f"
13309
13310 # Sed expression to map a string onto a valid CPP name.
13311 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13312
13313 # Sed expression to map a string onto a valid variable name.
13314 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13315
13316
13317 # IFS
13318 # We need space, tab and new line, in precisely that order.
13319 as_nl='
13320 '
13321 IFS="   $as_nl"
13322
13323 # CDPATH.
13324 $as_unset CDPATH
13325
13326 exec 6>&1
13327
13328 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13329 # report actual input values of CONFIG_FILES etc. instead of their
13330 # values after options handling.  Logging --version etc. is OK.
13331 exec 5>>config.log
13332 {
13333   echo
13334   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13335 ## Running $as_me. ##
13336 _ASBOX
13337 } >&5
13338 cat >&5 <<_CSEOF
13339
13340 This file was extended by $as_me, which was
13341 generated by GNU Autoconf 2.59.  Invocation command line was
13342
13343   CONFIG_FILES    = $CONFIG_FILES
13344   CONFIG_HEADERS  = $CONFIG_HEADERS
13345   CONFIG_LINKS    = $CONFIG_LINKS
13346   CONFIG_COMMANDS = $CONFIG_COMMANDS
13347   $ $0 $@
13348
13349 _CSEOF
13350 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13351 echo >&5
13352 _ACEOF
13353
13354 # Files that config.status was made for.
13355 if test -n "$ac_config_files"; then
13356   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13357 fi
13358
13359 if test -n "$ac_config_headers"; then
13360   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13361 fi
13362
13363 if test -n "$ac_config_links"; then
13364   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13365 fi
13366
13367 if test -n "$ac_config_commands"; then
13368   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13369 fi
13370
13371 cat >>$CONFIG_STATUS <<\_ACEOF
13372
13373 ac_cs_usage="\
13374 \`$as_me' instantiates files from templates according to the
13375 current configuration.
13376
13377 Usage: $0 [OPTIONS] [FILE]...
13378
13379   -h, --help       print this help, then exit
13380   -V, --version    print version number, then exit
13381   -q, --quiet      do not print progress messages
13382   -d, --debug      don't remove temporary files
13383       --recheck    update $as_me by reconfiguring in the same conditions
13384   --file=FILE[:TEMPLATE]
13385                    instantiate the configuration file FILE
13386
13387 Configuration files:
13388 $config_files
13389
13390 Report bugs to <bug-autoconf@gnu.org>."
13391 _ACEOF
13392
13393 cat >>$CONFIG_STATUS <<_ACEOF
13394 ac_cs_version="\\
13395 config.status
13396 configured by $0, generated by GNU Autoconf 2.59,
13397   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13398
13399 Copyright (C) 2003 Free Software Foundation, Inc.
13400 This config.status script is free software; the Free Software Foundation
13401 gives unlimited permission to copy, distribute and modify it."
13402 srcdir=$srcdir
13403 INSTALL="$INSTALL"
13404 _ACEOF
13405
13406 cat >>$CONFIG_STATUS <<\_ACEOF
13407 # If no file are specified by the user, then we need to provide default
13408 # value.  By we need to know if files were specified by the user.
13409 ac_need_defaults=:
13410 while test $# != 0
13411 do
13412   case $1 in
13413   --*=*)
13414     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13415     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13416     ac_shift=:
13417     ;;
13418   -*)
13419     ac_option=$1
13420     ac_optarg=$2
13421     ac_shift=shift
13422     ;;
13423   *) # This is not an option, so the user has probably given explicit
13424      # arguments.
13425      ac_option=$1
13426      ac_need_defaults=false;;
13427   esac
13428
13429   case $ac_option in
13430   # Handling of the options.
13431 _ACEOF
13432 cat >>$CONFIG_STATUS <<\_ACEOF
13433   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13434     ac_cs_recheck=: ;;
13435   --version | --vers* | -V )
13436     echo "$ac_cs_version"; exit 0 ;;
13437   --he | --h)
13438     # Conflict between --help and --header
13439     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13440 Try \`$0 --help' for more information." >&5
13441 echo "$as_me: error: ambiguous option: $1
13442 Try \`$0 --help' for more information." >&2;}
13443    { (exit 1); exit 1; }; };;
13444   --help | --hel | -h )
13445     echo "$ac_cs_usage"; exit 0 ;;
13446   --debug | --d* | -d )
13447     debug=: ;;
13448   --file | --fil | --fi | --f )
13449     $ac_shift
13450     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13451     ac_need_defaults=false;;
13452   --header | --heade | --head | --hea )
13453     $ac_shift
13454     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13455     ac_need_defaults=false;;
13456   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13457   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13458     ac_cs_silent=: ;;
13459
13460   # This is an error.
13461   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13462 Try \`$0 --help' for more information." >&5
13463 echo "$as_me: error: unrecognized option: $1
13464 Try \`$0 --help' for more information." >&2;}
13465    { (exit 1); exit 1; }; } ;;
13466
13467   *) ac_config_targets="$ac_config_targets $1" ;;
13468
13469   esac
13470   shift
13471 done
13472
13473 ac_configure_extra_args=
13474
13475 if $ac_cs_silent; then
13476   exec 6>/dev/null
13477   ac_configure_extra_args="$ac_configure_extra_args --silent"
13478 fi
13479
13480 _ACEOF
13481 cat >>$CONFIG_STATUS <<_ACEOF
13482 if \$ac_cs_recheck; then
13483   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13484   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13485 fi
13486
13487 _ACEOF
13488
13489
13490
13491
13492
13493 cat >>$CONFIG_STATUS <<\_ACEOF
13494 for ac_config_target in $ac_config_targets
13495 do
13496   case "$ac_config_target" in
13497   # Handling of arguments.
13498   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13499   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13500 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13501    { (exit 1); exit 1; }; };;
13502   esac
13503 done
13504
13505 # If the user did not use the arguments to specify the items to instantiate,
13506 # then the envvar interface is used.  Set only those that are not.
13507 # We use the long form for the default assignment because of an extremely
13508 # bizarre bug on SunOS 4.1.3.
13509 if $ac_need_defaults; then
13510   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13511 fi
13512
13513 # Have a temporary directory for convenience.  Make it in the build tree
13514 # simply because there is no reason to put it here, and in addition,
13515 # creating and moving files from /tmp can sometimes cause problems.
13516 # Create a temporary directory, and hook for its removal unless debugging.
13517 $debug ||
13518 {
13519   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13520   trap '{ (exit 1); exit 1; }' 1 2 13 15
13521 }
13522
13523 # Create a (secure) tmp directory for tmp files.
13524
13525 {
13526   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13527   test -n "$tmp" && test -d "$tmp"
13528 }  ||
13529 {
13530   tmp=./confstat$$-$RANDOM
13531   (umask 077 && mkdir $tmp)
13532 } ||
13533 {
13534    echo "$me: cannot create a temporary directory in ." >&2
13535    { (exit 1); exit 1; }
13536 }
13537
13538 _ACEOF
13539
13540 cat >>$CONFIG_STATUS <<_ACEOF
13541
13542 #
13543 # CONFIG_FILES section.
13544 #
13545
13546 # No need to generate the scripts if there are no CONFIG_FILES.
13547 # This happens for instance when ./config.status config.h
13548 if test -n "\$CONFIG_FILES"; then
13549   # Protect against being on the right side of a sed subst in config.status.
13550   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13551    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13552 s,@SHELL@,$SHELL,;t t
13553 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13554 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13555 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13556 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13557 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13558 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13559 s,@exec_prefix@,$exec_prefix,;t t
13560 s,@prefix@,$prefix,;t t
13561 s,@program_transform_name@,$program_transform_name,;t t
13562 s,@bindir@,$bindir,;t t
13563 s,@sbindir@,$sbindir,;t t
13564 s,@libexecdir@,$libexecdir,;t t
13565 s,@datadir@,$datadir,;t t
13566 s,@sysconfdir@,$sysconfdir,;t t
13567 s,@sharedstatedir@,$sharedstatedir,;t t
13568 s,@localstatedir@,$localstatedir,;t t
13569 s,@libdir@,$libdir,;t t
13570 s,@includedir@,$includedir,;t t
13571 s,@oldincludedir@,$oldincludedir,;t t
13572 s,@infodir@,$infodir,;t t
13573 s,@mandir@,$mandir,;t t
13574 s,@build_alias@,$build_alias,;t t
13575 s,@host_alias@,$host_alias,;t t
13576 s,@target_alias@,$target_alias,;t t
13577 s,@DEFS@,$DEFS,;t t
13578 s,@ECHO_C@,$ECHO_C,;t t
13579 s,@ECHO_N@,$ECHO_N,;t t
13580 s,@ECHO_T@,$ECHO_T,;t t
13581 s,@LIBS@,$LIBS,;t t
13582 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13583 s,@build@,$build,;t t
13584 s,@build_cpu@,$build_cpu,;t t
13585 s,@build_vendor@,$build_vendor,;t t
13586 s,@build_os@,$build_os,;t t
13587 s,@build_noncanonical@,$build_noncanonical,;t t
13588 s,@host_noncanonical@,$host_noncanonical,;t t
13589 s,@target_noncanonical@,$target_noncanonical,;t t
13590 s,@host@,$host,;t t
13591 s,@host_cpu@,$host_cpu,;t t
13592 s,@host_vendor@,$host_vendor,;t t
13593 s,@host_os@,$host_os,;t t
13594 s,@target@,$target,;t t
13595 s,@target_cpu@,$target_cpu,;t t
13596 s,@target_vendor@,$target_vendor,;t t
13597 s,@target_os@,$target_os,;t t
13598 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13599 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13600 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13601 s,@LN@,$LN,;t t
13602 s,@LN_S@,$LN_S,;t t
13603 s,@build_libsubdir@,$build_libsubdir,;t t
13604 s,@build_subdir@,$build_subdir,;t t
13605 s,@host_subdir@,$host_subdir,;t t
13606 s,@target_subdir@,$target_subdir,;t t
13607 s,@CC@,$CC,;t t
13608 s,@CFLAGS@,$CFLAGS,;t t
13609 s,@LDFLAGS@,$LDFLAGS,;t t
13610 s,@CPPFLAGS@,$CPPFLAGS,;t t
13611 s,@ac_ct_CC@,$ac_ct_CC,;t t
13612 s,@EXEEXT@,$EXEEXT,;t t
13613 s,@OBJEXT@,$OBJEXT,;t t
13614 s,@CXX@,$CXX,;t t
13615 s,@CXXFLAGS@,$CXXFLAGS,;t t
13616 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13617 s,@GNATBIND@,$GNATBIND,;t t
13618 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13619 s,@GNATMAKE@,$GNATMAKE,;t t
13620 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13621 s,@do_compare@,$do_compare,;t t
13622 s,@gmplibs@,$gmplibs,;t t
13623 s,@gmpinc@,$gmpinc,;t t
13624 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13625 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13626 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13627 s,@stage1_ldflags@,$stage1_ldflags,;t t
13628 s,@stage1_libs@,$stage1_libs,;t t
13629 s,@poststage1_ldflags@,$poststage1_ldflags,;t t
13630 s,@poststage1_libs@,$poststage1_libs,;t t
13631 s,@ppllibs@,$ppllibs,;t t
13632 s,@pplinc@,$pplinc,;t t
13633 s,@clooglibs@,$clooglibs,;t t
13634 s,@clooginc@,$clooginc,;t t
13635 s,@stage1_languages@,$stage1_languages,;t t
13636 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13637 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13638 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13639 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13640 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13641 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13642 s,@tooldir@,$tooldir,;t t
13643 s,@build_tooldir@,$build_tooldir,;t t
13644 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13645 s,@GDB_TK@,$GDB_TK,;t t
13646 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13647 s,@build_configargs@,$build_configargs,;t t
13648 s,@build_configdirs@,$build_configdirs,;t t
13649 s,@host_configargs@,$host_configargs,;t t
13650 s,@configdirs@,$configdirs,;t t
13651 s,@target_configargs@,$target_configargs,;t t
13652 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13653 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13654 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13655 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13656 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13657 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13658 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13659 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13660 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13661 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13662 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13663 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13664 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13665 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13666 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13667 s,@config_shell@,$config_shell,;t t
13668 s,@YACC@,$YACC,;t t
13669 s,@BISON@,$BISON,;t t
13670 s,@M4@,$M4,;t t
13671 s,@LEX@,$LEX,;t t
13672 s,@FLEX@,$FLEX,;t t
13673 s,@MAKEINFO@,$MAKEINFO,;t t
13674 s,@EXPECT@,$EXPECT,;t t
13675 s,@RUNTEST@,$RUNTEST,;t t
13676 s,@AR@,$AR,;t t
13677 s,@AS@,$AS,;t t
13678 s,@DLLTOOL@,$DLLTOOL,;t t
13679 s,@LD@,$LD,;t t
13680 s,@LIPO@,$LIPO,;t t
13681 s,@NM@,$NM,;t t
13682 s,@RANLIB@,$RANLIB,;t t
13683 s,@STRIP@,$STRIP,;t t
13684 s,@WINDRES@,$WINDRES,;t t
13685 s,@WINDMC@,$WINDMC,;t t
13686 s,@OBJCOPY@,$OBJCOPY,;t t
13687 s,@OBJDUMP@,$OBJDUMP,;t t
13688 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13689 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13690 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13691 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13692 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13693 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13694 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13695 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13696 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13697 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13698 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13699 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13700 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13701 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13702 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13703 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13704 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13705 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13706 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13707 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13708 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13709 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13710 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13711 s,@MAINT@,$MAINT,;t t
13712 s,@stage1_cflags@,$stage1_cflags,;t t
13713 s,@stage1_checking@,$stage1_checking,;t t
13714 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13715 s,@datarootdir@,$datarootdir,;t t
13716 s,@docdir@,$docdir,;t t
13717 s,@pdfdir@,$pdfdir,;t t
13718 s,@htmldir@,$htmldir,;t t
13719 s,@compare_exclusions@,$compare_exclusions,;t t
13720 s,@LIBOBJS@,$LIBOBJS,;t t
13721 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13722 /@serialization_dependencies@/r $serialization_dependencies
13723 s,@serialization_dependencies@,,;t t
13724 /@host_makefile_frag@/r $host_makefile_frag
13725 s,@host_makefile_frag@,,;t t
13726 /@target_makefile_frag@/r $target_makefile_frag
13727 s,@target_makefile_frag@,,;t t
13728 /@alphaieee_frag@/r $alphaieee_frag
13729 s,@alphaieee_frag@,,;t t
13730 /@ospace_frag@/r $ospace_frag
13731 s,@ospace_frag@,,;t t
13732 CEOF
13733
13734 _ACEOF
13735
13736   cat >>$CONFIG_STATUS <<\_ACEOF
13737   # Split the substitutions into bite-sized pieces for seds with
13738   # small command number limits, like on Digital OSF/1 and HP-UX.
13739   ac_max_sed_lines=48
13740   ac_sed_frag=1 # Number of current file.
13741   ac_beg=1 # First line for current file.
13742   ac_end=$ac_max_sed_lines # Line after last line for current file.
13743   ac_more_lines=:
13744   ac_sed_cmds=
13745   while $ac_more_lines; do
13746     if test $ac_beg -gt 1; then
13747       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13748     else
13749       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13750     fi
13751     if test ! -s $tmp/subs.frag; then
13752       ac_more_lines=false
13753     else
13754       # The purpose of the label and of the branching condition is to
13755       # speed up the sed processing (if there are no `@' at all, there
13756       # is no need to browse any of the substitutions).
13757       # These are the two extra sed commands mentioned above.
13758       (echo ':t
13759   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13760       if test -z "$ac_sed_cmds"; then
13761         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13762       else
13763         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13764       fi
13765       ac_sed_frag=`expr $ac_sed_frag + 1`
13766       ac_beg=$ac_end
13767       ac_end=`expr $ac_end + $ac_max_sed_lines`
13768     fi
13769   done
13770   if test -z "$ac_sed_cmds"; then
13771     ac_sed_cmds=cat
13772   fi
13773 fi # test -n "$CONFIG_FILES"
13774
13775 _ACEOF
13776 cat >>$CONFIG_STATUS <<\_ACEOF
13777 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13778   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13779   case $ac_file in
13780   - | *:- | *:-:* ) # input from stdin
13781         cat >$tmp/stdin
13782         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13783         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13784   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13785         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13786   * )   ac_file_in=$ac_file.in ;;
13787   esac
13788
13789   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13790   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13791 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13792          X"$ac_file" : 'X\(//\)[^/]' \| \
13793          X"$ac_file" : 'X\(//\)$' \| \
13794          X"$ac_file" : 'X\(/\)' \| \
13795          .     : '\(.\)' 2>/dev/null ||
13796 echo X"$ac_file" |
13797     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13798           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13799           /^X\(\/\/\)$/{ s//\1/; q; }
13800           /^X\(\/\).*/{ s//\1/; q; }
13801           s/.*/./; q'`
13802   { if $as_mkdir_p; then
13803     mkdir -p "$ac_dir"
13804   else
13805     as_dir="$ac_dir"
13806     as_dirs=
13807     while test ! -d "$as_dir"; do
13808       as_dirs="$as_dir $as_dirs"
13809       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13810 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13811          X"$as_dir" : 'X\(//\)[^/]' \| \
13812          X"$as_dir" : 'X\(//\)$' \| \
13813          X"$as_dir" : 'X\(/\)' \| \
13814          .     : '\(.\)' 2>/dev/null ||
13815 echo X"$as_dir" |
13816     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13817           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13818           /^X\(\/\/\)$/{ s//\1/; q; }
13819           /^X\(\/\).*/{ s//\1/; q; }
13820           s/.*/./; q'`
13821     done
13822     test ! -n "$as_dirs" || mkdir $as_dirs
13823   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13824 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13825    { (exit 1); exit 1; }; }; }
13826
13827   ac_builddir=.
13828
13829 if test "$ac_dir" != .; then
13830   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13831   # A "../" for each directory in $ac_dir_suffix.
13832   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13833 else
13834   ac_dir_suffix= ac_top_builddir=
13835 fi
13836
13837 case $srcdir in
13838   .)  # No --srcdir option.  We are building in place.
13839     ac_srcdir=.
13840     if test -z "$ac_top_builddir"; then
13841        ac_top_srcdir=.
13842     else
13843        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13844     fi ;;
13845   [\\/]* | ?:[\\/]* )  # Absolute path.
13846     ac_srcdir=$srcdir$ac_dir_suffix;
13847     ac_top_srcdir=$srcdir ;;
13848   *) # Relative path.
13849     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13850     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13851 esac
13852
13853 # Do not use `cd foo && pwd` to compute absolute paths, because
13854 # the directories may not exist.
13855 case `pwd` in
13856 .) ac_abs_builddir="$ac_dir";;
13857 *)
13858   case "$ac_dir" in
13859   .) ac_abs_builddir=`pwd`;;
13860   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13861   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13862   esac;;
13863 esac
13864 case $ac_abs_builddir in
13865 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13866 *)
13867   case ${ac_top_builddir}. in
13868   .) ac_abs_top_builddir=$ac_abs_builddir;;
13869   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13870   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13871   esac;;
13872 esac
13873 case $ac_abs_builddir in
13874 .) ac_abs_srcdir=$ac_srcdir;;
13875 *)
13876   case $ac_srcdir in
13877   .) ac_abs_srcdir=$ac_abs_builddir;;
13878   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13879   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13880   esac;;
13881 esac
13882 case $ac_abs_builddir in
13883 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13884 *)
13885   case $ac_top_srcdir in
13886   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13887   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13888   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13889   esac;;
13890 esac
13891
13892
13893   case $INSTALL in
13894   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13895   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13896   esac
13897
13898   if test x"$ac_file" != x-; then
13899     { echo "$as_me:$LINENO: creating $ac_file" >&5
13900 echo "$as_me: creating $ac_file" >&6;}
13901     rm -f "$ac_file"
13902   fi
13903   # Let's still pretend it is `configure' which instantiates (i.e., don't
13904   # use $as_me), people would be surprised to read:
13905   #    /* config.h.  Generated by config.status.  */
13906   if test x"$ac_file" = x-; then
13907     configure_input=
13908   else
13909     configure_input="$ac_file.  "
13910   fi
13911   configure_input=$configure_input"Generated from `echo $ac_file_in |
13912                                      sed 's,.*/,,'` by configure."
13913
13914   # First look for the input files in the build tree, otherwise in the
13915   # src tree.
13916   ac_file_inputs=`IFS=:
13917     for f in $ac_file_in; do
13918       case $f in
13919       -) echo $tmp/stdin ;;
13920       [\\/$]*)
13921          # Absolute (can't be DOS-style, as IFS=:)
13922          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13923 echo "$as_me: error: cannot find input file: $f" >&2;}
13924    { (exit 1); exit 1; }; }
13925          echo "$f";;
13926       *) # Relative
13927          if test -f "$f"; then
13928            # Build tree
13929            echo "$f"
13930          elif test -f "$srcdir/$f"; then
13931            # Source tree
13932            echo "$srcdir/$f"
13933          else
13934            # /dev/null tree
13935            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13936 echo "$as_me: error: cannot find input file: $f" >&2;}
13937    { (exit 1); exit 1; }; }
13938          fi;;
13939       esac
13940     done` || { (exit 1); exit 1; }
13941 _ACEOF
13942 cat >>$CONFIG_STATUS <<_ACEOF
13943   sed "$ac_vpsub
13944 $extrasub
13945 _ACEOF
13946 cat >>$CONFIG_STATUS <<\_ACEOF
13947 :t
13948 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13949 s,@configure_input@,$configure_input,;t t
13950 s,@srcdir@,$ac_srcdir,;t t
13951 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13952 s,@top_srcdir@,$ac_top_srcdir,;t t
13953 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13954 s,@builddir@,$ac_builddir,;t t
13955 s,@abs_builddir@,$ac_abs_builddir,;t t
13956 s,@top_builddir@,$ac_top_builddir,;t t
13957 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13958 s,@INSTALL@,$ac_INSTALL,;t t
13959 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13960   rm -f $tmp/stdin
13961   if test x"$ac_file" != x-; then
13962     mv $tmp/out $ac_file
13963   else
13964     cat $tmp/out
13965     rm -f $tmp/out
13966   fi
13967
13968 done
13969 _ACEOF
13970
13971 cat >>$CONFIG_STATUS <<\_ACEOF
13972
13973 { (exit 0); exit 0; }
13974 _ACEOF
13975 chmod +x $CONFIG_STATUS
13976 ac_clean_files=$ac_clean_files_save
13977
13978
13979 # configure is writing to config.log, and then calls config.status.
13980 # config.status does its own redirection, appending to config.log.
13981 # Unfortunately, on DOS this fails, as config.log is still kept open
13982 # by configure, so config.status won't be able to write to it; its
13983 # output is simply discarded.  So we exec the FD to /dev/null,
13984 # effectively closing config.log, so it can be properly (re)opened and
13985 # appended to by config.status.  When coming back to configure, we
13986 # need to make the FD available again.
13987 if test "$no_create" != yes; then
13988   ac_cs_success=:
13989   ac_config_status_args=
13990   test "$silent" = yes &&
13991     ac_config_status_args="$ac_config_status_args --quiet"
13992   exec 5>/dev/null
13993   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13994   exec 5>>config.log
13995   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13996   # would make configure fail if this is the last instruction.
13997   $ac_cs_success || { (exit 1); exit 1; }
13998 fi
13999