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 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 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   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpc=PATH        specify prefix directory for installed MPC package.
 960                           Equivalent to --with-mpc-include=PATH/include
 961                           plus --with-mpc-lib=PATH/lib
 962   --with-mpc-include=PATH
 963                           specify directory for installed MPC include files
 964   --with-mpc-lib=PATH    specify directory for the installed MPC library
 965   --with-mpfr-dir=PATH    this option has been REMOVED
 966   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 967                           Equivalent to --with-mpfr-include=PATH/include
 968                           plus --with-mpfr-lib=PATH/lib
 969   --with-mpfr-include=PATH
 970                           specify directory for installed MPFR include files
 971   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 972   --with-gmp-dir=PATH     this option has been REMOVED
 973   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 974                           Equivalent to --with-gmp-include=PATH/include
 975                           plus --with-gmp-lib=PATH/lib
 976   --with-gmp-include=PATH specify directory for installed GMP include files
 977   --with-gmp-lib=PATH     specify directory for the installed GMP library
 978   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 979                           when linking with PPL
 980   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 981                           Equivalent to --with-ppl-include=PATH/include
 982                           plus --with-ppl-lib=PATH/lib
 983   --with-ppl-include=PATH Specify directory for installed PPL include files
 984   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 985   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 986                           Equivalent to --with-cloog-include=PATH/include
 987                           plus --with-cloog-lib=PATH/lib
 988   --with-cloog-include=PATH Specify directory for installed CLooG include files
 989   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 990   --with-build-sysroot=SYSROOT
 991                           use sysroot as the system root during the build
 992   --with-debug-prefix-map='A=B C=D ...'
 993                              map A to B, C to D ... in debug information
 994   --with-build-time-tools=PATH
 995                           use given path to find target tools during the build
 996   --with-datarootdir      use datarootdir as the data root directory.
 997   --with-docdir           install documentation in this directory.
 998   --with-pdfdir           install pdf in this directory.
 999   --with-htmldir          install html in this directory.
1000
1001 Some influential environment variables:
1002   CC          C compiler command
1003   CFLAGS      C compiler flags
1004   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1005               nonstandard directory <lib dir>
1006   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1007               headers in a nonstandard directory <include dir>
1008   CXX         C++ compiler command
1009   CXXFLAGS    C++ compiler flags
1010   AR          AR for the host
1011   AS          AS for the host
1012   DLLTOOL     DLLTOOL for the host
1013   LD          LD for the host
1014   LIPO        LIPO for the host
1015   NM          NM for the host
1016   RANLIB      RANLIB for the host
1017   STRIP       STRIP for the host
1018   WINDRES     WINDRES for the host
1019   WINDMC      WINDMC for the host
1020   OBJCOPY     OBJCOPY for the host
1021   OBJDUMP     OBJDUMP for the host
1022   CC_FOR_TARGET
1023               CC for the target
1024   CXX_FOR_TARGET
1025               CXX for the target
1026   GCC_FOR_TARGET
1027               GCC for the target
1028   GCJ_FOR_TARGET
1029               GCJ for the target
1030   GFORTRAN_FOR_TARGET
1031               GFORTRAN for the target
1032   AR_FOR_TARGET
1033               AR for the target
1034   AS_FOR_TARGET
1035               AS for the target
1036   DLLTOOL_FOR_TARGET
1037               DLLTOOL for the target
1038   LD_FOR_TARGET
1039               LD for the target
1040   LIPO_FOR_TARGET
1041               LIPO for the target
1042   NM_FOR_TARGET
1043               NM for the target
1044   OBJDUMP_FOR_TARGET
1045               OBJDUMP for the target
1046   RANLIB_FOR_TARGET
1047               RANLIB for the target
1048   STRIP_FOR_TARGET
1049               STRIP for the target
1050   WINDRES_FOR_TARGET
1051               WINDRES for the target
1052   WINDMC_FOR_TARGET
1053               WINDMC for the target
1054
1055 Use these variables to override the choices made by `configure' or to help
1056 it to find libraries and programs with nonstandard names/locations.
1057
1058 _ACEOF
1059 fi
1060
1061 if test "$ac_init_help" = "recursive"; then
1062   # If there are subdirs, report their specific --help.
1063   ac_popdir=`pwd`
1064   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1065     test -d $ac_dir || continue
1066     ac_builddir=.
1067
1068 if test "$ac_dir" != .; then
1069   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1070   # A "../" for each directory in $ac_dir_suffix.
1071   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1072 else
1073   ac_dir_suffix= ac_top_builddir=
1074 fi
1075
1076 case $srcdir in
1077   .)  # No --srcdir option.  We are building in place.
1078     ac_srcdir=.
1079     if test -z "$ac_top_builddir"; then
1080        ac_top_srcdir=.
1081     else
1082        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1083     fi ;;
1084   [\\/]* | ?:[\\/]* )  # Absolute path.
1085     ac_srcdir=$srcdir$ac_dir_suffix;
1086     ac_top_srcdir=$srcdir ;;
1087   *) # Relative path.
1088     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1089     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1090 esac
1091
1092 # Do not use `cd foo && pwd` to compute absolute paths, because
1093 # the directories may not exist.
1094 case `pwd` in
1095 .) ac_abs_builddir="$ac_dir";;
1096 *)
1097   case "$ac_dir" in
1098   .) ac_abs_builddir=`pwd`;;
1099   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1100   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1101   esac;;
1102 esac
1103 case $ac_abs_builddir in
1104 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1105 *)
1106   case ${ac_top_builddir}. in
1107   .) ac_abs_top_builddir=$ac_abs_builddir;;
1108   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1109   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1110   esac;;
1111 esac
1112 case $ac_abs_builddir in
1113 .) ac_abs_srcdir=$ac_srcdir;;
1114 *)
1115   case $ac_srcdir in
1116   .) ac_abs_srcdir=$ac_abs_builddir;;
1117   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1118   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1119   esac;;
1120 esac
1121 case $ac_abs_builddir in
1122 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1123 *)
1124   case $ac_top_srcdir in
1125   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1126   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1127   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1128   esac;;
1129 esac
1130
1131     cd $ac_dir
1132     # Check for guested configure; otherwise get Cygnus style configure.
1133     if test -f $ac_srcdir/configure.gnu; then
1134       echo
1135       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1136     elif test -f $ac_srcdir/configure; then
1137       echo
1138       $SHELL $ac_srcdir/configure  --help=recursive
1139     elif test -f $ac_srcdir/configure.ac ||
1140            test -f $ac_srcdir/configure.in; then
1141       echo
1142       $ac_configure --help
1143     else
1144       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1145     fi
1146     cd $ac_popdir
1147   done
1148 fi
1149
1150 test -n "$ac_init_help" && exit 0
1151 if $ac_init_version; then
1152   cat <<\_ACEOF
1153
1154 Copyright (C) 2003 Free Software Foundation, Inc.
1155 This configure script is free software; the Free Software Foundation
1156 gives unlimited permission to copy, distribute and modify it.
1157 _ACEOF
1158   exit 0
1159 fi
1160 exec 5>config.log
1161 cat >&5 <<_ACEOF
1162 This file contains any messages produced by compilers while
1163 running configure, to aid debugging if configure makes a mistake.
1164
1165 It was created by $as_me, which was
1166 generated by GNU Autoconf 2.59.  Invocation command line was
1167
1168   $ $0 $@
1169
1170 _ACEOF
1171 {
1172 cat <<_ASUNAME
1173 ## --------- ##
1174 ## Platform. ##
1175 ## --------- ##
1176
1177 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1178 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1179 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1180 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1181 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1182
1183 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1184 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1185
1186 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1187 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1188 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1189 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1190 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1191 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1192 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1193
1194 _ASUNAME
1195
1196 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1197 for as_dir in $PATH
1198 do
1199   IFS=$as_save_IFS
1200   test -z "$as_dir" && as_dir=.
1201   echo "PATH: $as_dir"
1202 done
1203
1204 } >&5
1205
1206 cat >&5 <<_ACEOF
1207
1208
1209 ## ----------- ##
1210 ## Core tests. ##
1211 ## ----------- ##
1212
1213 _ACEOF
1214
1215
1216 # Keep a trace of the command line.
1217 # Strip out --no-create and --no-recursion so they do not pile up.
1218 # Strip out --silent because we don't want to record it for future runs.
1219 # Also quote any args containing shell meta-characters.
1220 # Make two passes to allow for proper duplicate-argument suppression.
1221 ac_configure_args=
1222 ac_configure_args0=
1223 ac_configure_args1=
1224 ac_sep=
1225 ac_must_keep_next=false
1226 for ac_pass in 1 2
1227 do
1228   for ac_arg
1229   do
1230     case $ac_arg in
1231     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1232     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1233     | -silent | --silent | --silen | --sile | --sil)
1234       continue ;;
1235     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1236       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1237     esac
1238     case $ac_pass in
1239     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1240     2)
1241       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1242       if test $ac_must_keep_next = true; then
1243         ac_must_keep_next=false # Got value, back to normal.
1244       else
1245         case $ac_arg in
1246           *=* | --config-cache | -C | -disable-* | --disable-* \
1247           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1248           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1249           | -with-* | --with-* | -without-* | --without-* | --x)
1250             case "$ac_configure_args0 " in
1251               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1252             esac
1253             ;;
1254           -* ) ac_must_keep_next=true ;;
1255         esac
1256       fi
1257       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1258       # Get rid of the leading space.
1259       ac_sep=" "
1260       ;;
1261     esac
1262   done
1263 done
1264 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1265 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1266
1267 # When interrupted or exit'd, cleanup temporary files, and complete
1268 # config.log.  We remove comments because anyway the quotes in there
1269 # would cause problems or look ugly.
1270 # WARNING: Be sure not to use single quotes in there, as some shells,
1271 # such as our DU 5.0 friend, will then `close' the trap.
1272 trap 'exit_status=$?
1273   # Save into config.log some information that might help in debugging.
1274   {
1275     echo
1276
1277     cat <<\_ASBOX
1278 ## ---------------- ##
1279 ## Cache variables. ##
1280 ## ---------------- ##
1281 _ASBOX
1282     echo
1283     # The following way of writing the cache mishandles newlines in values,
1284 {
1285   (set) 2>&1 |
1286     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1287     *ac_space=\ *)
1288       sed -n \
1289         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1290           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1291       ;;
1292     *)
1293       sed -n \
1294         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1295       ;;
1296     esac;
1297 }
1298     echo
1299
1300     cat <<\_ASBOX
1301 ## ----------------- ##
1302 ## Output variables. ##
1303 ## ----------------- ##
1304 _ASBOX
1305     echo
1306     for ac_var in $ac_subst_vars
1307     do
1308       eval ac_val=$`echo $ac_var`
1309       echo "$ac_var='"'"'$ac_val'"'"'"
1310     done | sort
1311     echo
1312
1313     if test -n "$ac_subst_files"; then
1314       cat <<\_ASBOX
1315 ## ------------- ##
1316 ## Output files. ##
1317 ## ------------- ##
1318 _ASBOX
1319       echo
1320       for ac_var in $ac_subst_files
1321       do
1322         eval ac_val=$`echo $ac_var`
1323         echo "$ac_var='"'"'$ac_val'"'"'"
1324       done | sort
1325       echo
1326     fi
1327
1328     if test -s confdefs.h; then
1329       cat <<\_ASBOX
1330 ## ----------- ##
1331 ## confdefs.h. ##
1332 ## ----------- ##
1333 _ASBOX
1334       echo
1335       sed "/^$/d" confdefs.h | sort
1336       echo
1337     fi
1338     test "$ac_signal" != 0 &&
1339       echo "$as_me: caught signal $ac_signal"
1340     echo "$as_me: exit $exit_status"
1341   } >&5
1342   rm -f core *.core &&
1343   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1344     exit $exit_status
1345      ' 0
1346 for ac_signal in 1 2 13 15; do
1347   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1348 done
1349 ac_signal=0
1350
1351 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1352 rm -rf conftest* confdefs.h
1353 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1354 echo >confdefs.h
1355
1356 # Predefined preprocessor variables.
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_NAME "$PACKAGE_NAME"
1360 _ACEOF
1361
1362
1363 cat >>confdefs.h <<_ACEOF
1364 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1365 _ACEOF
1366
1367
1368 cat >>confdefs.h <<_ACEOF
1369 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1370 _ACEOF
1371
1372
1373 cat >>confdefs.h <<_ACEOF
1374 #define PACKAGE_STRING "$PACKAGE_STRING"
1375 _ACEOF
1376
1377
1378 cat >>confdefs.h <<_ACEOF
1379 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1380 _ACEOF
1381
1382
1383 # Let the site file select an alternate cache file if it wants to.
1384 # Prefer explicitly selected file to automatically selected ones.
1385 if test -z "$CONFIG_SITE"; then
1386   if test "x$prefix" != xNONE; then
1387     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1388   else
1389     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1390   fi
1391 fi
1392 for ac_site_file in $CONFIG_SITE; do
1393   if test -r "$ac_site_file"; then
1394     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1395 echo "$as_me: loading site script $ac_site_file" >&6;}
1396     sed 's/^/| /' "$ac_site_file" >&5
1397     . "$ac_site_file"
1398   fi
1399 done
1400
1401 if test -r "$cache_file"; then
1402   # Some versions of bash will fail to source /dev/null (special
1403   # files actually), so we avoid doing that.
1404   if test -f "$cache_file"; then
1405     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1406 echo "$as_me: loading cache $cache_file" >&6;}
1407     case $cache_file in
1408       [\\/]* | ?:[\\/]* ) . $cache_file;;
1409       *)                      . ./$cache_file;;
1410     esac
1411   fi
1412 else
1413   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1414 echo "$as_me: creating cache $cache_file" >&6;}
1415   >$cache_file
1416 fi
1417
1418 # Check that the precious variables saved in the cache have kept the same
1419 # value.
1420 ac_cache_corrupted=false
1421 for ac_var in `(set) 2>&1 |
1422                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1423   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1424   eval ac_new_set=\$ac_env_${ac_var}_set
1425   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1426   eval ac_new_val="\$ac_env_${ac_var}_value"
1427   case $ac_old_set,$ac_new_set in
1428     set,)
1429       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1430 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1431       ac_cache_corrupted=: ;;
1432     ,set)
1433       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1434 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1435       ac_cache_corrupted=: ;;
1436     ,);;
1437     *)
1438       if test "x$ac_old_val" != "x$ac_new_val"; then
1439         # differences in whitespace do not lead to failure.
1440         ac_old_val_w=`echo x $ac_old_val`
1441         ac_new_val_w=`echo x $ac_new_val`
1442         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1443           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1444 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1445           ac_cache_corrupted=:
1446         else
1447           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1448 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1449           eval $ac_var=\$ac_old_val
1450         fi
1451         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1452 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1453         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1454 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1455       fi;;
1456   esac
1457   # Pass precious variables to config.status.
1458   if test "$ac_new_set" = set; then
1459     case $ac_new_val in
1460     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1461       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1462     *) ac_arg=$ac_var=$ac_new_val ;;
1463     esac
1464     case " $ac_configure_args " in
1465       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1466       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1467     esac
1468   fi
1469 done
1470 if $ac_cache_corrupted; then
1471   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1472 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1473   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1474 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1475   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1476 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1477    { (exit 1); exit 1; }; }
1478 fi
1479
1480 ac_ext=c
1481 ac_cpp='$CPP $CPPFLAGS'
1482 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1483 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1484 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509 progname=$0
1510 # if PWD already has a value, it is probably wrong.
1511 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1512
1513 # Export original configure arguments for use by sub-configures.
1514 # Quote arguments with shell meta charatcers.
1515 TOPLEVEL_CONFIGURE_ARGUMENTS=
1516 set -- "$progname" "$@"
1517 for ac_arg
1518 do
1519   case "$ac_arg" in
1520   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1521     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1522     # if the argument is of the form -foo=baz, quote the baz part only
1523     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1524   *) ;;
1525   esac
1526   # Add the quoted argument to the list.
1527   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1528 done
1529 if test "$silent" = yes; then
1530   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1531 fi
1532 # Remove the initial space we just introduced and, as these will be
1533 # expanded by make, quote '$'.
1534 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1535
1536
1537 # Find the build, host, and target systems.
1538 ac_aux_dir=
1539 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1540   if test -f $ac_dir/install-sh; then
1541     ac_aux_dir=$ac_dir
1542     ac_install_sh="$ac_aux_dir/install-sh -c"
1543     break
1544   elif test -f $ac_dir/install.sh; then
1545     ac_aux_dir=$ac_dir
1546     ac_install_sh="$ac_aux_dir/install.sh -c"
1547     break
1548   elif test -f $ac_dir/shtool; then
1549     ac_aux_dir=$ac_dir
1550     ac_install_sh="$ac_aux_dir/shtool install -c"
1551     break
1552   fi
1553 done
1554 if test -z "$ac_aux_dir"; then
1555   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1556 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1557    { (exit 1); exit 1; }; }
1558 fi
1559 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1560 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1561 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1562
1563 # Make sure we can run config.sub.
1564 $ac_config_sub sun4 >/dev/null 2>&1 ||
1565   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1566 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 echo "$as_me:$LINENO: checking build system type" >&5
1570 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1571 if test "${ac_cv_build+set}" = set; then
1572   echo $ECHO_N "(cached) $ECHO_C" >&6
1573 else
1574   ac_cv_build_alias=$build_alias
1575 test -z "$ac_cv_build_alias" &&
1576   ac_cv_build_alias=`$ac_config_guess`
1577 test -z "$ac_cv_build_alias" &&
1578   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1579 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1580    { (exit 1); exit 1; }; }
1581 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1582   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1583 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1584    { (exit 1); exit 1; }; }
1585
1586 fi
1587 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1588 echo "${ECHO_T}$ac_cv_build" >&6
1589 build=$ac_cv_build
1590 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1591 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1592 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1593
1594
1595  case ${build_alias} in
1596   "") build_noncanonical=${build} ;;
1597   *) build_noncanonical=${build_alias} ;;
1598 esac
1599
1600
1601
1602  case ${host_alias} in
1603   "") host_noncanonical=${build_noncanonical} ;;
1604   *) host_noncanonical=${host_alias} ;;
1605 esac
1606
1607
1608
1609  case ${target_alias} in
1610   "") target_noncanonical=${host_noncanonical} ;;
1611   *) target_noncanonical=${target_alias} ;;
1612 esac
1613
1614
1615
1616
1617 test "$host_noncanonical" = "$target_noncanonical" &&
1618   test "$program_prefix$program_suffix$program_transform_name" = \
1619     NONENONEs,x,x, &&
1620   program_transform_name=s,y,y,
1621
1622 echo "$as_me:$LINENO: checking host system type" >&5
1623 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1624 if test "${ac_cv_host+set}" = set; then
1625   echo $ECHO_N "(cached) $ECHO_C" >&6
1626 else
1627   ac_cv_host_alias=$host_alias
1628 test -z "$ac_cv_host_alias" &&
1629   ac_cv_host_alias=$ac_cv_build_alias
1630 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1631   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1632 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1633    { (exit 1); exit 1; }; }
1634
1635 fi
1636 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1637 echo "${ECHO_T}$ac_cv_host" >&6
1638 host=$ac_cv_host
1639 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1640 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1641 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1642
1643
1644 echo "$as_me:$LINENO: checking target system type" >&5
1645 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1646 if test "${ac_cv_target+set}" = set; then
1647   echo $ECHO_N "(cached) $ECHO_C" >&6
1648 else
1649   ac_cv_target_alias=$target_alias
1650 test "x$ac_cv_target_alias" = "x" &&
1651   ac_cv_target_alias=$ac_cv_host_alias
1652 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1653   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1654 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1655    { (exit 1); exit 1; }; }
1656
1657 fi
1658 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1659 echo "${ECHO_T}$ac_cv_target" >&6
1660 target=$ac_cv_target
1661 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1662 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1663 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1664
1665
1666 # The aliases save the names the user supplied, while $host etc.
1667 # will get canonicalized.
1668 test -n "$target_alias" &&
1669   test "$program_prefix$program_suffix$program_transform_name" = \
1670     NONENONEs,x,x, &&
1671   program_prefix=${target_alias}-
1672 test "$program_prefix" != NONE &&
1673   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1674 # Use a double $ so make ignores it.
1675 test "$program_suffix" != NONE &&
1676   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1677 # Double any \ or $.  echo might interpret backslashes.
1678 # By default was `s,x,x', remove it if useless.
1679 cat <<\_ACEOF >conftest.sed
1680 s/[\\$]/&&/g;s/;s,x,x,$//
1681 _ACEOF
1682 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1683 rm conftest.sed
1684
1685
1686
1687 # Get 'install' or 'install-sh' and its variants.
1688 # Find a good install program.  We prefer a C program (faster),
1689 # so one script is as good as another.  But avoid the broken or
1690 # incompatible versions:
1691 # SysV /etc/install, /usr/sbin/install
1692 # SunOS /usr/etc/install
1693 # IRIX /sbin/install
1694 # AIX /bin/install
1695 # AmigaOS /C/install, which installs bootblocks on floppy discs
1696 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1697 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1698 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1699 # OS/2's system install, which has a completely different semantic
1700 # ./install, which can be erroneously created by make from ./install.sh.
1701 # Reject install programs that cannot install multiple files.
1702 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1703 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1704 if test -z "$INSTALL"; then
1705 if test "${ac_cv_path_install+set}" = set; then
1706   echo $ECHO_N "(cached) $ECHO_C" >&6
1707 else
1708   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1709 for as_dir in $PATH
1710 do
1711   IFS=$as_save_IFS
1712   test -z "$as_dir" && as_dir=.
1713   # Account for people who put trailing slashes in PATH elements.
1714 case $as_dir/ in
1715   ./ | .// | /cC/* | \
1716   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1717   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1718   /usr/ucb/* ) ;;
1719   *)
1720     # OSF1 and SCO ODT 3.0 have their own names for install.
1721     # Don't use installbsd from OSF since it installs stuff as root
1722     # by default.
1723     for ac_prog in ginstall scoinst install; do
1724       for ac_exec_ext in '' $ac_executable_extensions; do
1725         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1726           if test $ac_prog = install &&
1727             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1728             # AIX install.  It has an incompatible calling convention.
1729             :
1730           elif test $ac_prog = install &&
1731             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1732             # program-specific install script used by HP pwplus--don't use.
1733             :
1734           else
1735             rm -rf conftest.one conftest.two conftest.dir
1736             echo one > conftest.one
1737             echo two > conftest.two
1738             mkdir conftest.dir
1739             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1740               test -s conftest.one && test -s conftest.two &&
1741               test -s conftest.dir/conftest.one &&
1742               test -s conftest.dir/conftest.two
1743             then
1744               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1745               break 3
1746             fi
1747           fi
1748         fi
1749       done
1750     done
1751     ;;
1752 esac
1753 done
1754
1755 rm -rf conftest.one conftest.two conftest.dir
1756
1757 fi
1758   if test "${ac_cv_path_install+set}" = set; then
1759     INSTALL=$ac_cv_path_install
1760   else
1761     # As a last resort, use the slow shell script.  Don't cache a
1762     # value for INSTALL within a source directory, because that will
1763     # break other packages using the cache if that directory is
1764     # removed, or if the value is a relative name.
1765     INSTALL=$ac_install_sh
1766   fi
1767 fi
1768 echo "$as_me:$LINENO: result: $INSTALL" >&5
1769 echo "${ECHO_T}$INSTALL" >&6
1770
1771 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1772 # It thinks the first close brace ends the variable substitution.
1773 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1774
1775 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1776
1777 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1778
1779 echo "$as_me:$LINENO: checking whether ln works" >&5
1780 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1781 if test "${acx_cv_prog_LN+set}" = set; then
1782   echo $ECHO_N "(cached) $ECHO_C" >&6
1783 else
1784   rm -f conftestdata_t
1785 echo >conftestdata_f
1786 if ln conftestdata_f conftestdata_t 2>/dev/null
1787 then
1788   acx_cv_prog_LN=ln
1789 else
1790   acx_cv_prog_LN=no
1791 fi
1792 rm -f conftestdata_f conftestdata_t
1793
1794 fi
1795 if test $acx_cv_prog_LN = no; then
1796   LN="cp"
1797   echo "$as_me:$LINENO: result: no, using $LN" >&5
1798 echo "${ECHO_T}no, using $LN" >&6
1799 else
1800   LN="$acx_cv_prog_LN"
1801   echo "$as_me:$LINENO: result: yes" >&5
1802 echo "${ECHO_T}yes" >&6
1803 fi
1804
1805 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1806 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1807 LN_S=$as_ln_s
1808 if test "$LN_S" = "ln -s"; then
1809   echo "$as_me:$LINENO: result: yes" >&5
1810 echo "${ECHO_T}yes" >&6
1811 else
1812   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1813 echo "${ECHO_T}no, using $LN_S" >&6
1814 fi
1815
1816
1817 ### we might need to use some other shell than /bin/sh for running subshells
1818 ### If we are on Windows, search for the shell.  This will permit people
1819 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1820 ### without also having to set CONFIG_SHELL.  This code will work when
1821 ### using bash, which sets OSTYPE.
1822 case "${OSTYPE}" in
1823 *win32*)
1824   if test x${CONFIG_SHELL} = x ; then
1825     if test ! -f /bin/sh ; then
1826       if test x${SHELL} != x && test -f ${SHELL} ; then
1827         CONFIG_SHELL=${SHELL}
1828         export CONFIG_SHELL
1829       else
1830         for prog in sh sh.exe bash bash.exe; do
1831           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1832           for dir in $PATH; do
1833             test -z "$dir" && dir=.
1834             if test -f $dir/$prog; then
1835               CONFIG_SHELL=$dir/$prog
1836               export CONFIG_SHELL
1837               break
1838             fi
1839           done
1840           IFS="$save_ifs"
1841           test -n "${CONFIG_SHELL}" && break
1842         done
1843       fi
1844     fi
1845   fi
1846   ;;
1847 esac
1848
1849 config_shell=${CONFIG_SHELL-/bin/sh}
1850
1851 moveifchange=${srcdir}/move-if-change
1852
1853 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1854
1855 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1856 # a relative path.
1857 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1858   INSTALL="${srcpwd}/install-sh -c"
1859 fi
1860
1861 # Set srcdir to "." if that's what it is.
1862 # This is important for multilib support.
1863 pwd=`${PWDCMD-pwd}`
1864 if test "${pwd}" = "${srcpwd}" ; then
1865   srcdir=.
1866 fi
1867
1868 topsrcdir=$srcpwd
1869
1870 extra_host_args=
1871
1872 ### To add a new directory to the tree, first choose whether it is a target
1873 ### or a host dependent tool.  Then put it into the appropriate list
1874 ### (library or tools, host or target), doing a dependency sort.
1875
1876 # Subdirs will be configured in the order listed in build_configdirs,
1877 # configdirs, or target_configdirs; see the serialization section below.
1878
1879 # Dependency sorting is only needed when *configuration* must be done in
1880 # a particular order.  In all cases a dependency should be specified in
1881 # the Makefile, whether or not it's implicitly specified here.
1882
1883 # Double entries in build_configdirs, configdirs, or target_configdirs may
1884 # cause circular dependencies and break everything horribly.
1885
1886 # these library is used by various programs built for the build
1887 # environment
1888 #
1889 build_libs="build-libiberty"
1890
1891 # these tools are built for the build environment
1892 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1893
1894 # these libraries are used by various programs built for the host environment
1895 #
1896 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr mpc ppl cloog libiconv"
1897
1898 # these tools are built for the host environment
1899 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1900 # know that we are building the simulator.
1901 # binutils, gas and ld appear in that order because it makes sense to run
1902 # "make check" in that particular order.
1903 # If --enable-gold is used, "gold" will replace "ld".
1904 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc 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"
1905
1906 # libgcj represents the runtime libraries only used by gcj.
1907 libgcj="target-libffi \
1908         target-zlib \
1909         target-qthreads \
1910         target-libjava"
1911
1912 # these libraries are built for the target environment, and are built after
1913 # the host libraries and the host tools (which may be a cross compiler)
1914 #
1915 target_libraries="target-libgcc \
1916                 target-libiberty \
1917                 target-libgloss \
1918                 target-newlib \
1919                 target-libgomp \
1920                 target-libstdc++-v3 \
1921                 target-libmudflap \
1922                 target-libssp \
1923                 target-libgfortran \
1924                 target-boehm-gc \
1925                 ${libgcj} \
1926                 target-libobjc \
1927                 target-libada"
1928
1929 # these tools are built using the target libraries, and are intended to
1930 # run only in the target environment
1931 #
1932 # note: any program that *uses* libraries that are in the "target_libraries"
1933 # list belongs in this list.  those programs are also very likely
1934 # candidates for the "native_only" list which follows
1935 #
1936 target_tools="target-examples target-groff target-gperf target-rda"
1937
1938 ################################################################################
1939
1940 ## All tools belong in one of the four categories, and are assigned above
1941 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1942 ## is important because configure will choke if they ever get through.
1943 ## ${configdirs} is directories we build using the host tools.
1944 ## ${target_configdirs} is directories we build using the target tools.
1945 configdirs=`echo ${host_libs} ${host_tools}`
1946 target_configdirs=`echo ${target_libraries} ${target_tools}`
1947 build_configdirs=`echo ${build_libs} ${build_tools}`
1948
1949
1950
1951 ################################################################################
1952
1953 srcname="gnu development package"
1954
1955 # This gets set non-empty for some net releases of packages.
1956 appdirs=""
1957
1958 # Define is_cross_compiler to save on calls to 'test'.
1959 is_cross_compiler=
1960 if test x"${host}" = x"${target}" ; then
1961   is_cross_compiler=no
1962 else
1963   is_cross_compiler=yes
1964 fi
1965
1966 # Find the build and target subdir names.
1967
1968 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1969 # have matching libraries, they should use host libraries: Makefile.tpl
1970 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1971 # However, they still use the build modules, because the corresponding
1972 # host modules (e.g. bison) are only built for the host when bootstrap
1973 # finishes. So:
1974 # - build_subdir is where we find build modules, and never changes.
1975 # - build_libsubdir is where we find build libraries, and can be overridden.
1976
1977 # Prefix 'build-' so this never conflicts with target_subdir.
1978 build_subdir="build-${build_noncanonical}"
1979
1980 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1981 if test "${with_build_libsubdir+set}" = set; then
1982   withval="$with_build_libsubdir"
1983   build_libsubdir="$withval"
1984 else
1985   build_libsubdir="$build_subdir"
1986 fi;
1987 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1988 if ( test $srcdir = . && test -d gcc ) \
1989    || test -d $srcdir/../host-${host_noncanonical}; then
1990   host_subdir="host-${host_noncanonical}"
1991 else
1992   host_subdir=.
1993 fi
1994 # No prefix.
1995 target_subdir=${target_noncanonical}
1996
1997
1998 # Skipdirs are removed silently.
1999 skipdirs=
2000 # Noconfigdirs are removed loudly.
2001 noconfigdirs=""
2002
2003 use_gnu_ld=
2004 # Make sure we don't let GNU ld be added if we didn't want it.
2005 if test x$with_gnu_ld = xno ; then
2006   use_gnu_ld=no
2007   noconfigdirs="$noconfigdirs ld gold"
2008 fi
2009
2010 use_gnu_as=
2011 # Make sure we don't let GNU as be added if we didn't want it.
2012 if test x$with_gnu_as = xno ; then
2013   use_gnu_as=no
2014   noconfigdirs="$noconfigdirs gas"
2015 fi
2016
2017 # some tools are so dependent upon X11 that if we're not building with X,
2018 # it's not even worth trying to configure, much less build, that tool.
2019
2020 case ${with_x} in
2021   yes | "") ;; # the default value for this tree is that X11 is available
2022   no)
2023     skipdirs="${skipdirs} tk itcl libgui"
2024     # We won't be able to build gdbtk without X.
2025     enable_gdbtk=no
2026     ;;
2027   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2028 esac
2029
2030 # Some tools are only suitable for building in a "native" situation.
2031 # Remove these if host!=target.
2032 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"
2033
2034 # Similarly, some are only suitable for cross toolchains.
2035 # Remove these if host=target.
2036 cross_only="target-libgloss target-newlib target-opcodes"
2037
2038 case $is_cross_compiler in
2039   no) skipdirs="${skipdirs} ${cross_only}" ;;
2040   yes) skipdirs="${skipdirs} ${native_only}" ;;
2041 esac
2042
2043 # If both --with-headers and --with-libs are specified, default to
2044 # --without-newlib.
2045 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2046    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2047   if test x"${with_newlib}" = x ; then
2048     with_newlib=no
2049   fi
2050 fi
2051
2052 # Recognize --with-newlib/--without-newlib.
2053 case ${with_newlib} in
2054   no) skipdirs="${skipdirs} target-newlib" ;;
2055   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2056 esac
2057
2058 # Handle --enable-gold.
2059
2060 # Check whether --enable-gold or --disable-gold was given.
2061 if test "${enable_gold+set}" = set; then
2062   enableval="$enable_gold"
2063   ENABLE_GOLD=$enableval
2064 else
2065   ENABLE_GOLD=no
2066 fi;
2067 if test "${ENABLE_GOLD}" = "yes"; then
2068   # Check for ELF target.
2069   is_elf=no
2070   case "${target}" in
2071     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2072     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2073     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2074       case "${target}" in
2075         *-*-linux*aout* | *-*-linux*oldld*)
2076           ;;
2077         *)
2078           is_elf=yes
2079           ;;
2080       esac
2081   esac
2082
2083   if test "$is_elf" = "yes"; then
2084     # Check for target supported by gold.
2085     case "${target}" in
2086       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-* | arm*-*-*)
2087         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2088         ;;
2089     esac
2090   fi
2091 fi
2092
2093 # Configure extra directories which are host specific
2094
2095 case "${host}" in
2096   *-cygwin*)
2097     configdirs="$configdirs libtermcap" ;;
2098 esac
2099
2100 # A target can indicate whether a language isn't supported for some reason.
2101 # Only spaces may be used in this macro; not newlines or tabs.
2102 unsupported_languages=
2103
2104 # Remove more programs from consideration, based on the host or
2105 # target this usually means that a port of the program doesn't
2106 # exist yet.
2107
2108 case "${host}" in
2109   hppa*64*-*-*)
2110     noconfigdirs="$noconfigdirs byacc"
2111     ;;
2112   i[3456789]86-*-vsta)
2113     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2114     ;;
2115   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2116     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2117     ;;
2118   x86_64-*-mingw*)
2119     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2120     ;;
2121   i[3456789]86-*-mingw32*)
2122     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2123     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2124     ;;
2125   i[3456789]86-*-beos*)
2126     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2127     ;;
2128   *-*-cygwin*)
2129     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2130     ;;
2131   *-*-netbsd*)
2132     noconfigdirs="$noconfigdirs rcs"
2133     ;;
2134   ppc*-*-pe)
2135     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2136     ;;
2137   powerpc-*-beos*)
2138     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2139     ;;
2140 esac
2141
2142
2143 # Check whether --enable-libada or --disable-libada was given.
2144 if test "${enable_libada+set}" = set; then
2145   enableval="$enable_libada"
2146   ENABLE_LIBADA=$enableval
2147 else
2148   ENABLE_LIBADA=yes
2149 fi;
2150 if test "${ENABLE_LIBADA}" != "yes" ; then
2151   noconfigdirs="$noconfigdirs gnattools"
2152 fi
2153
2154 # Check whether --enable-libssp or --disable-libssp was given.
2155 if test "${enable_libssp+set}" = set; then
2156   enableval="$enable_libssp"
2157   ENABLE_LIBSSP=$enableval
2158 else
2159   ENABLE_LIBSSP=yes
2160 fi;
2161
2162 # Save it here so that, even in case of --enable-libgcj, if the Java
2163 # front-end isn't enabled, we still get libgcj disabled.
2164 libgcj_saved=$libgcj
2165 case $enable_libgcj in
2166 yes)
2167   # If we reset it here, it won't get added to noconfigdirs in the
2168   # target-specific build rules, so it will be forcibly enabled
2169   # (unless the Java language itself isn't enabled).
2170   libgcj=
2171   ;;
2172 no)
2173   # Make sure we get it printed in the list of not supported target libs.
2174   noconfigdirs="$noconfigdirs ${libgcj}"
2175   ;;
2176 esac
2177
2178
2179 # Disable libmudflap on some systems.
2180 if test x$enable_libmudflap = x ; then
2181     case "${target}" in
2182     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2183         # Enable libmudflap by default in GNU and friends.
2184         ;;
2185     *-*-freebsd*)
2186         # Enable libmudflap by default in FreeBSD.
2187         ;;
2188     *)
2189         # Disable it by default everywhere else.
2190         noconfigdirs="$noconfigdirs target-libmudflap"
2191         ;;
2192     esac
2193 fi
2194
2195 # Disable libgomp on non POSIX hosted systems.
2196 if test x$enable_libgomp = x ; then
2197     # Enable libgomp by default on hosted POSIX systems.
2198     case "${target}" in
2199     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2200         ;;
2201     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2202         ;;
2203     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2204         ;;
2205     *-*-darwin* | *-*-aix*)
2206         ;;
2207     *)
2208         noconfigdirs="$noconfigdirs target-libgomp"
2209         ;;
2210     esac
2211 fi
2212
2213 # Default libgloss CPU subdirectory.
2214 libgloss_dir="$target_cpu"
2215
2216 case "${target}" in
2217   *-*-chorusos)
2218     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2219     ;;
2220   powerpc-*-darwin*)
2221     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2222     noconfigdirs="$noconfigdirs sim target-rda"
2223     ;;
2224   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2225     noconfigdirs="$noconfigdirs ld gas gprof"
2226     noconfigdirs="$noconfigdirs sim target-rda"
2227     ;;
2228   *-*-darwin*)
2229     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2230     noconfigdirs="$noconfigdirs sim target-rda"
2231     noconfigdirs="$noconfigdirs ${libgcj}"
2232     ;;
2233   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2234     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2235     ;;
2236   *-*-freebsd*)
2237     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2238     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2239         && test -f /usr/local/include/gmp.h; then
2240       with_gmp=/usr/local
2241     fi
2242
2243     # Skip some stuff that's unsupported on some FreeBSD configurations.
2244     case "${target}" in
2245       i*86-*-*) ;;
2246       alpha*-*-*) ;;
2247       *)
2248         noconfigdirs="$noconfigdirs ${libgcj}"
2249         ;;
2250     esac
2251     ;;
2252   *-*-kaos*)
2253     # Remove unsupported stuff on all kaOS configurations.
2254     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2255     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2256     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2257     noconfigdirs="$noconfigdirs target-libgloss"
2258     ;;
2259   *-*-netbsd*)
2260     # Skip some stuff on all NetBSD configurations.
2261     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2262
2263     # Skip some stuff that's unsupported on some NetBSD configurations.
2264     case "${target}" in
2265       i*86-*-netbsdelf*) ;;
2266       arm*-*-netbsdelf*) ;;
2267       *)
2268         noconfigdirs="$noconfigdirs ${libgcj}"
2269         ;;
2270     esac
2271     ;;
2272   *-*-netware*)
2273     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2274     ;;
2275   *-*-rtems*)
2276     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2277     ;;
2278     # The tpf target doesn't support gdb yet.
2279   *-*-tpf*)
2280     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2281     ;;
2282   *-*-uclinux*)
2283     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2284     ;;
2285   *-*-vxworks*)
2286     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2287     ;;
2288   alpha*-dec-osf*)
2289     # ld works, but does not support shared libraries.
2290     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2291     # gas doesn't generate exception information.
2292     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2293     ;;
2294   alpha*-*-*vms*)
2295     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2296     ;;
2297   alpha*-*-linux*)
2298     # newlib is not 64 bit ready
2299     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2300     ;;
2301   alpha*-*-*)
2302     # newlib is not 64 bit ready
2303     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2304     ;;
2305   am33_2.0-*-linux*)
2306     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2307     ;;
2308   sh-*-linux*)
2309     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2310     ;;
2311   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2312     noconfigdirs="$noconfigdirs ${libgcj}"
2313     noconfigdirs="$noconfigdirs target-examples"
2314     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2315     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2316     noconfigdirs="$noconfigdirs expect dejagnu"
2317     # the C++ libraries don't build on top of CE's C libraries
2318     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2319     noconfigdirs="$noconfigdirs target-newlib"
2320     case "${host}" in
2321       *-*-cygwin*) ;; # keep gdb and readline
2322       *) noconfigdirs="$noconfigdirs gdb readline"
2323          ;;
2324     esac
2325     libgloss_dir=wince
2326     ;;
2327   arc-*-*)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   arm-semi-aof )
2331     ;;
2332   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2333     noconfigdirs="$noconfigdirs ${libgcj}"
2334     libgloss_dir=arm
2335     ;;
2336   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2337     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2338     libgloss_dir=arm
2339     ;;
2340   arm*-*-linux-gnueabi)
2341     noconfigdirs="$noconfigdirs target-qthreads"
2342     case ${with_newlib} in
2343       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2344     esac
2345     libgloss_dir=arm
2346     ;;
2347   arm*-*-symbianelf*)
2348     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2349     libgloss_dir=arm
2350     ;;
2351   arm-*-pe*)
2352     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2353     ;;
2354   thumb-*-coff)
2355     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2356     ;;
2357   thumb-*-elf)
2358     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2359     ;;
2360   thumb-*-pe)
2361     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2362     ;;
2363   arm-*-riscix*)
2364     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2365     ;;
2366   avr-*-*)
2367     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2368     ;;
2369   bfin-*-*)
2370     noconfigdirs="$noconfigdirs gdb"
2371     if test x${is_cross_compiler} != xno ; then
2372       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2373     fi
2374     ;;
2375   c4x-*-* | tic4x-*-*)
2376     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2377     ;;
2378   c54x*-*-* | tic54x-*-*)
2379     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2380     ;;
2381   cr16-*-*)
2382     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2383     ;;
2384   cris-*-* | crisv32-*-*)
2385     unsupported_languages="$unsupported_languages java"
2386     case "${target}" in
2387       *-*-aout)
2388         unsupported_languages="$unsupported_languages fortran"
2389         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2390       *-*-elf)
2391         noconfigdirs="$noconfigdirs target-boehm-gc";;
2392       *-*-linux*)
2393         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2394       *)
2395         unsupported_languages="$unsupported_languages fortran"
2396         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2397     esac
2398     libgloss_dir=cris
2399     ;;
2400   crx-*-*)
2401     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2402     ;;
2403   d10v-*-*)
2404     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2405     ;;
2406   d30v-*-*)
2407     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2408     ;;
2409   ep9312-*-elf | ep9312-*-coff)
2410     libgloss_dir=arm
2411     ;;
2412   fr30-*-elf*)
2413     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2414     ;;
2415   frv-*-*)
2416     noconfigdirs="$noconfigdirs ${libgcj}"
2417     ;;
2418   moxie-*-*)
2419     noconfigdirs="$noconfigdirs ${libgcj}"
2420     noconfigdirs="$noconfigdirs gprof"
2421     ;;
2422   h8300*-*-*)
2423     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2424     ;;
2425   h8500-*-*)
2426     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2427     ;;
2428   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2429     ;;
2430   hppa*64*-*-linux* | parisc*64*-*-linux*)
2431     # In this case, it's because the hppa64-linux target is for
2432     # the kernel only at this point and has no libc, and thus no
2433     # headers, crt*.o, etc., all of which are needed by these.
2434     noconfigdirs="$noconfigdirs target-zlib"
2435     ;;
2436   parisc*-*-linux* | hppa*-*-linux*)
2437     ;;
2438   hppa*-*-*elf* | \
2439   hppa*-*-lites* | \
2440   hppa*-*-openbsd* | \
2441   hppa*64*-*-*)
2442     noconfigdirs="$noconfigdirs ${libgcj}"
2443     ;;
2444   hppa*-hp-hpux11*)
2445     noconfigdirs="$noconfigdirs ld shellutils"
2446     ;;
2447   hppa*-*-pro*)
2448     libgloss_dir=pa
2449     ;;
2450   hppa*-*-*)
2451     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2452     # build on HP-UX 10.20.
2453     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2454     ;;
2455   i960-*-*)
2456     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2457     ;;
2458   ia64*-*-elf*)
2459     # No gdb support yet.
2460     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2461     ;;
2462   ia64*-**-hpux*)
2463     # No gdb or ld support yet.
2464     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2465     ;;
2466   ia64*-*-*vms*)
2467     # No gdb or ld support yet.
2468     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2469     ;;
2470   i370-*-opened*)
2471     ;;
2472   i[3456789]86-*-coff | i[3456789]86-*-elf)
2473     noconfigdirs="$noconfigdirs ${libgcj}"
2474     libgloss_dir=i386
2475     ;;
2476   i[3456789]86-*-linux*)
2477     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2478     # not build java stuff by default.
2479     case "${target}" in
2480       *-*-*libc1*)
2481         noconfigdirs="$noconfigdirs ${libgcj}";;
2482     esac
2483
2484     # This section makes it possible to build newlib natively on linux.
2485     # If we are using a cross compiler then don't configure newlib.
2486     if test x${is_cross_compiler} != xno ; then
2487       noconfigdirs="$noconfigdirs target-newlib"
2488     fi
2489     noconfigdirs="$noconfigdirs target-libgloss"
2490     # If we are not using a cross compiler, do configure newlib.
2491     # Note however, that newlib will only be configured in this situation
2492     # if the --with-newlib option has been given, because otherwise
2493     # 'target-newlib' will appear in skipdirs.
2494     ;;
2495   i[3456789]86-*-mingw32*)
2496     target_configdirs="$target_configdirs target-winsup"
2497     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2498     ;;
2499   x86_64-*-mingw*)
2500     target_configdirs="$target_configdirs target-winsup"
2501     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2502     ;;
2503   *-*-cygwin*)
2504     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2505     noconfigdirs="$noconfigdirs target-gperf target-libgloss"
2506     # always build newlib if winsup directory is present.
2507     if test -d "$srcdir/winsup/cygwin"; then
2508       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2509     elif test -d "$srcdir/newlib"; then
2510       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2511     fi
2512     ;;
2513   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2514   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2515     ;;
2516   i[3456789]86-*-pe)
2517     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2518     ;;
2519   i[3456789]86-*-sco3.2v5*)
2520     # The linker does not yet know about weak symbols in COFF,
2521     # and is not configured to handle mixed ELF and COFF.
2522     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2523     ;;
2524   i[3456789]86-*-sco*)
2525     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2526     ;;
2527   i[3456789]86-*-solaris2*)
2528     noconfigdirs="$noconfigdirs target-libgloss"
2529     ;;
2530   i[3456789]86-*-sysv4*)
2531     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2532     ;;
2533   i[3456789]86-*-beos*)
2534     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2535     ;;
2536   i[3456789]86-*-rdos*)
2537     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2538     ;;
2539   m32r-*-*)
2540     noconfigdirs="$noconfigdirs ${libgcj}"
2541     ;;
2542   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2543     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2544     libgloss_dir=m68hc11
2545     ;;
2546   m68k-*-elf*)
2547     noconfigdirs="$noconfigdirs ${libgcj}"
2548     ;;
2549   m68k-*-coff*)
2550     noconfigdirs="$noconfigdirs ${libgcj}"
2551     ;;
2552   m68*-*-* | fido-*-*)
2553     libgloss_dir=m68k
2554     ;;
2555   mcore-*-pe*)
2556   # The EPOC C++ environment does not support exceptions or rtti,
2557   # and so building libstdc++-v3 tends not to always work.
2558     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2559     ;;
2560   mmix-*-*)
2561     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2562     unsupported_languages="$unsupported_languages fortran java"
2563     ;;
2564   mn10200-*-*)
2565     noconfigdirs="$noconfigdirs ${libgcj}"
2566     ;;
2567   mn10300-*-*)
2568     noconfigdirs="$noconfigdirs ${libgcj}"
2569     ;;
2570   mt-*-*)
2571     noconfigdirs="$noconfigdirs sim"
2572     ;;
2573   powerpc-*-aix*)
2574     # copied from rs6000-*-* entry
2575     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2576     ;;
2577   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2578     target_configdirs="$target_configdirs target-winsup"
2579     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2580     # always build newlib.
2581     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2582     ;;
2583     # This is temporary until we can link against shared libraries
2584   powerpcle-*-solaris*)
2585     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2586     libgloss_dir=rs6000
2587     ;;
2588   powerpc-*-beos*)
2589     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2590     ;;
2591   powerpc-*-eabi)
2592     noconfigdirs="$noconfigdirs ${libgcj}"
2593     libgloss_dir=rs6000
2594     ;;
2595   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2596     libgloss_dir=rs6000
2597     ;;
2598   rs6000-*-lynxos*)
2599     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2600     ;;
2601   rs6000-*-aix*)
2602     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2603     ;;
2604   rs6000-*-*)
2605     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2606     ;;
2607   m68k-apollo-*)
2608     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2609     ;;
2610   mips*-sde-elf*)
2611     skipdirs="$skipdirs target-libiberty"
2612     noconfigdirs="$noconfigdirs ${libgcj}"
2613     if test x$with_newlib = xyes; then
2614       noconfigdirs="$noconfigdirs gprof"
2615     fi
2616     libgloss_dir=mips
2617     ;;
2618   mips*-*-irix5*)
2619     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2620     ;;
2621   mips*-*-irix6*)
2622     # Linking libjava exceeds command-line length limits on at least
2623     # IRIX 6.2, but not on IRIX 6.5.
2624     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2625     # <oldham@codesourcery.com>
2626     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2627     ;;
2628   mips*-*-bsd*)
2629     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2630     ;;
2631   mips*-*-linux*)
2632     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2633     ;;
2634   mips*-*-*)
2635     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2636     libgloss_dir=mips
2637     ;;
2638   romp-*-*)
2639     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2640     ;;
2641   sh-*-* | sh64-*-*)
2642     case "${host}" in
2643       i[3456789]86-*-vsta) ;; # don't add gprof back in
2644       i[3456789]86-*-go32*) ;; # don't add gprof back in
2645       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2646       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2647     esac
2648     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2649     ;;
2650   sparclet-*-aout* | sparc86x-*-*)
2651     libgloss_dir=sparc
2652     ;;
2653   sparc-*-elf*)
2654     noconfigdirs="$noconfigdirs ${libgcj}"
2655     ;;
2656   sparc64-*-elf*)
2657     noconfigdirs="$noconfigdirs ${libgcj}"
2658     libgloss_dir=sparc
2659     ;;
2660   sparclite-*-*)
2661     noconfigdirs="$noconfigdirs ${libgcj}"
2662     libgloss_dir=sparc
2663     ;;
2664   sparc-*-sunos4*)
2665     noconfigdirs="$noconfigdirs ${libgcj}"
2666     if test x${is_cross_compiler} != xno ; then
2667            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2668     else
2669            use_gnu_ld=no
2670     fi
2671     ;;
2672   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2673     noconfigdirs="$noconfigdirs ${libgcj}"
2674     ;;
2675   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2676     ;;
2677   v810-*-*)
2678     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2679     ;;
2680   v850-*-*)
2681     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2682     ;;
2683   v850e-*-*)
2684     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2685     ;;
2686   v850ea-*-*)
2687     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2688     ;;
2689   vax-*-vms)
2690     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2691     ;;
2692   vax-*-*)
2693     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2694     ;;
2695   xtensa*-*-*)
2696     noconfigdirs="$noconfigdirs ${libgcj}"
2697     ;;
2698   ip2k-*-*)
2699     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2700     ;;
2701   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2702     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2703     ;;
2704   *-*-lynxos*)
2705     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2706     ;;
2707   *-*-*)
2708     noconfigdirs="$noconfigdirs ${libgcj}"
2709     ;;
2710 esac
2711
2712 # If we aren't building newlib, then don't build libgloss, since libgloss
2713 # depends upon some newlib header files.
2714 case "${noconfigdirs}" in
2715   *target-libgloss*) ;;
2716   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2717 esac
2718
2719 # Work in distributions that contain no compiler tools, like Autoconf.
2720 tentative_cc=""
2721 host_makefile_frag=/dev/null
2722 if test -d ${srcdir}/config ; then
2723 case "${host}" in
2724   m68k-hp-hpux*)
2725     # Avoid "too much defining" errors from HPUX compiler.
2726     tentative_cc="cc -Wp,-H256000"
2727     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2728     # If it's HP/UX ar, this should be harmless.
2729     RANLIB="ar ts"
2730     ;;
2731   m68k-apollo-sysv*)
2732     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2733     ;;
2734   m68k-apollo-bsd*)
2735     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2736     # chokes on bfd, the compiler won't let you assign integers to enums, and
2737     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2738     # the apollo compiler" (the preferred version of GCC could be called cc,
2739     # or whatever), but I'm not sure leaving CC as cc is any better...
2740     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2741     # Used to have BISON=yacc.
2742     tentative_cc=gcc
2743     ;;
2744   m88k-dg-dgux*)
2745     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2746     ;;
2747   m88k-harris-cxux*)
2748     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2749     tentative_cc="cc -Xa"
2750     host_makefile_frag="config/mh-cxux"
2751     ;;
2752   m88k-motorola-sysv*)
2753     ;;
2754   mips*-dec-ultrix*)
2755     tentative_cc="cc -Wf,-XNg1000"
2756     host_makefile_frag="config/mh-decstation"
2757     ;;
2758   mips*-nec-sysv4*)
2759     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2760     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2761     host_makefile_frag="config/mh-necv4"
2762     ;;
2763   mips*-sgi-irix4*)
2764     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2765     # environment.  Also bump switch table size so that cp-parse will
2766     # compile.  Bump string length limit so linker builds.
2767     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2768     ;;
2769   mips*-*-sysv4*)
2770     host_makefile_frag="config/mh-sysv4"
2771     ;;
2772   mips*-*-sysv*)
2773     # This is for a MIPS running RISC/os 4.52C.
2774
2775     # This is needed for GDB, but needs to be in the top-level make because
2776     # if a library is compiled with the bsd headers and gets linked with the
2777     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2778     # a different size).
2779     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2780     # known except to select the sysv environment.  Could we use /proc instead?
2781     # These "sysv environments" and "bsd environments" often end up being a pain.
2782     #
2783     # This is not part of CFLAGS because perhaps not all C compilers have this
2784     # option.
2785     tentative_cc="cc -systype sysv"
2786     ;;
2787   i370-ibm-opened*)
2788     tentative_cc="c89"
2789     ;;
2790   i[3456789]86-*-sysv5*)
2791     host_makefile_frag="config/mh-sysv5"
2792     ;;
2793   i[3456789]86-*-dgux*)
2794     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2795     host_makefile_frag="config/mh-dgux386"
2796     ;;
2797   i[3456789]86-ncr-sysv4.3*)
2798     # The MetaWare compiler will generate a copyright message unless you
2799     # turn it off by adding the -Hnocopyr flag.
2800     tentative_cc="cc -Hnocopyr"
2801     ;;
2802   i[3456789]86-ncr-sysv4*)
2803     # for an NCR 3000 (i486/SVR4) system.
2804     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2805     # This compiler not only emits obnoxious copyright messages every time
2806     # you run it, but it chokes and dies on a whole bunch of GNU source
2807     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2808     tentative_cc="/usr/ccs/ATT/cc"
2809     host_makefile_frag="config/mh-ncr3000"
2810     ;;
2811   i[3456789]86-*-sco3.2v5*)
2812     ;;
2813   i[3456789]86-*-sco*)
2814     # The native C compiler botches some simple uses of const.  Unfortunately,
2815     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2816     tentative_cc="cc -Dconst="
2817     host_makefile_frag="config/mh-sco"
2818     ;;
2819   i[3456789]86-*-udk*)
2820     host_makefile_frag="config/mh-sysv5"
2821     ;;
2822   i[3456789]86-*-solaris2*)
2823     host_makefile_frag="config/mh-sysv4"
2824     ;;
2825   i[3456789]86-*-msdosdjgpp*)
2826     host_makefile_frag="config/mh-djgpp"
2827     ;;
2828   *-cygwin*)
2829
2830 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2831 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2832 echo a >cygwin-cat-check
2833 if test `cat cygwin-cat-check` == a ; then
2834   rm cygwin-cat-check
2835   echo "$as_me:$LINENO: result: yes" >&5
2836 echo "${ECHO_T}yes" >&6
2837 else
2838   rm cygwin-cat-check
2839   echo "$as_me:$LINENO: result: no" >&5
2840 echo "${ECHO_T}no" >&6
2841   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2842   Please either mount the build directory in binary mode or run the following
2843   commands before running any configure script:
2844 set -o igncr
2845 export SHELLOPTS
2846   " >&5
2847 echo "$as_me: error: The cat command does not ignore carriage return characters.
2848   Please either mount the build directory in binary mode or run the following
2849   commands before running any configure script:
2850 set -o igncr
2851 export SHELLOPTS
2852   " >&2;}
2853    { (exit 1); exit 1; }; }
2854 fi
2855
2856     host_makefile_frag="config/mh-cygwin"
2857     ;;
2858   *-mingw*)
2859     host_makefile_frag="config/mh-mingw"
2860     ;;
2861   *-interix*)
2862     host_makefile_frag="config/mh-interix"
2863     ;;
2864   vax-*-ultrix2*)
2865     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2866     tentative_cc=gcc
2867     ;;
2868   *-*-solaris2*)
2869     host_makefile_frag="config/mh-solaris"
2870     ;;
2871   m68k-sun-sunos*)
2872     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2873     # without overflowing the jump tables (-J says to use a 32 bit table)
2874     tentative_cc="cc -J"
2875     ;;
2876   hppa*-hp-hpux10*)
2877     tentative_cc="cc -Wp,-H256000"
2878     host_makefile_frag="config/mh-pa-hpux10"
2879     ;;
2880   hppa*-hp-hpux* | hppa*-*-hiux*)
2881     tentative_cc="cc -Wp,-H256000"
2882     host_makefile_frag="config/mh-pa"
2883     ;;
2884   hppa*-*)
2885     host_makefile_frag="config/mh-pa"
2886     ;;
2887   *-hp-hpux* | *-*-hiux*)
2888     tentative_cc="cc -Wp,-H256000"
2889     ;;
2890   rs6000-*-lynxos*)
2891     # /bin/cc is less than useful for our purposes.  Always use GCC
2892     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2893     host_makefile_frag="config/mh-lynxrs6k"
2894     ;;
2895   powerpc-*-darwin*)
2896     host_makefile_frag="config/mh-ppc-darwin"
2897     ;;
2898   powerpc-*-aix*)
2899     host_makefile_frag="config/mh-ppc-aix"
2900     ;;
2901   rs6000-*-aix*)
2902     host_makefile_frag="config/mh-ppc-aix"
2903     ;;
2904   *-*-lynxos*)
2905     # /bin/cc is less than useful for our purposes.  Always use GCC
2906     tentative_cc="/bin/gcc"
2907     ;;
2908   *-*-sysv4*)
2909     host_makefile_frag="config/mh-sysv4"
2910     ;;
2911   # This is placed last to prevent interfering with the cases above.
2912   i[3456789]86-*-*)
2913     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2914     host_makefile_frag="config/mh-x86omitfp"
2915     ;;
2916 esac
2917 fi
2918
2919 # If we aren't going to be using gcc, see if we can extract a definition
2920 # of CC from the fragment.
2921 # Actually, use the 'pre-extracted' version above.
2922 if test -z "${CC}" && test "${build}" = "${host}" ; then
2923   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2924   found=
2925   for dir in $PATH; do
2926     test -z "$dir" && dir=.
2927     if test -f $dir/gcc; then
2928       found=yes
2929       break
2930     fi
2931   done
2932   IFS="$save_ifs"
2933   if test -z "${found}" && test -n "${tentative_cc}" ; then
2934     CC=$tentative_cc
2935   fi
2936 fi
2937
2938 if test "${build}" != "${host}" ; then
2939   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2940   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2941   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2942   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2943   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2944   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2945   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2946   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2947   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2948   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2949   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2950   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2951 else
2952   AR_FOR_BUILD="\$(AR)"
2953   AS_FOR_BUILD="\$(AS)"
2954   CC_FOR_BUILD="\$(CC)"
2955   CXX_FOR_BUILD="\$(CXX)"
2956   GCJ_FOR_BUILD="\$(GCJ)"
2957   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2958   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2959   LD_FOR_BUILD="\$(LD)"
2960   NM_FOR_BUILD="\$(NM)"
2961   RANLIB_FOR_BUILD="\$(RANLIB)"
2962   WINDRES_FOR_BUILD="\$(WINDRES)"
2963   WINDMC_FOR_BUILD="\$(WINDMC)"
2964 fi
2965
2966 ac_ext=c
2967 ac_cpp='$CPP $CPPFLAGS'
2968 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2969 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2970 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2971 if test -n "$ac_tool_prefix"; then
2972   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2973 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2974 echo "$as_me:$LINENO: checking for $ac_word" >&5
2975 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2976 if test "${ac_cv_prog_CC+set}" = set; then
2977   echo $ECHO_N "(cached) $ECHO_C" >&6
2978 else
2979   if test -n "$CC"; then
2980   ac_cv_prog_CC="$CC" # Let the user override the test.
2981 else
2982 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2983 for as_dir in $PATH
2984 do
2985   IFS=$as_save_IFS
2986   test -z "$as_dir" && as_dir=.
2987   for ac_exec_ext in '' $ac_executable_extensions; do
2988   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2989     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2990     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2991     break 2
2992   fi
2993 done
2994 done
2995
2996 fi
2997 fi
2998 CC=$ac_cv_prog_CC
2999 if test -n "$CC"; then
3000   echo "$as_me:$LINENO: result: $CC" >&5
3001 echo "${ECHO_T}$CC" >&6
3002 else
3003   echo "$as_me:$LINENO: result: no" >&5
3004 echo "${ECHO_T}no" >&6
3005 fi
3006
3007 fi
3008 if test -z "$ac_cv_prog_CC"; then
3009   ac_ct_CC=$CC
3010   # Extract the first word of "gcc", so it can be a program name with args.
3011 set dummy gcc; ac_word=$2
3012 echo "$as_me:$LINENO: checking for $ac_word" >&5
3013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3014 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3015   echo $ECHO_N "(cached) $ECHO_C" >&6
3016 else
3017   if test -n "$ac_ct_CC"; then
3018   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3019 else
3020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3021 for as_dir in $PATH
3022 do
3023   IFS=$as_save_IFS
3024   test -z "$as_dir" && as_dir=.
3025   for ac_exec_ext in '' $ac_executable_extensions; do
3026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3027     ac_cv_prog_ac_ct_CC="gcc"
3028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3029     break 2
3030   fi
3031 done
3032 done
3033
3034 fi
3035 fi
3036 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3037 if test -n "$ac_ct_CC"; then
3038   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3039 echo "${ECHO_T}$ac_ct_CC" >&6
3040 else
3041   echo "$as_me:$LINENO: result: no" >&5
3042 echo "${ECHO_T}no" >&6
3043 fi
3044
3045   CC=$ac_ct_CC
3046 else
3047   CC="$ac_cv_prog_CC"
3048 fi
3049
3050 if test -z "$CC"; then
3051   if test -n "$ac_tool_prefix"; then
3052   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3053 set dummy ${ac_tool_prefix}cc; ac_word=$2
3054 echo "$as_me:$LINENO: checking for $ac_word" >&5
3055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3056 if test "${ac_cv_prog_CC+set}" = set; then
3057   echo $ECHO_N "(cached) $ECHO_C" >&6
3058 else
3059   if test -n "$CC"; then
3060   ac_cv_prog_CC="$CC" # Let the user override the test.
3061 else
3062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3063 for as_dir in $PATH
3064 do
3065   IFS=$as_save_IFS
3066   test -z "$as_dir" && as_dir=.
3067   for ac_exec_ext in '' $ac_executable_extensions; do
3068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3069     ac_cv_prog_CC="${ac_tool_prefix}cc"
3070     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3071     break 2
3072   fi
3073 done
3074 done
3075
3076 fi
3077 fi
3078 CC=$ac_cv_prog_CC
3079 if test -n "$CC"; then
3080   echo "$as_me:$LINENO: result: $CC" >&5
3081 echo "${ECHO_T}$CC" >&6
3082 else
3083   echo "$as_me:$LINENO: result: no" >&5
3084 echo "${ECHO_T}no" >&6
3085 fi
3086
3087 fi
3088 if test -z "$ac_cv_prog_CC"; then
3089   ac_ct_CC=$CC
3090   # Extract the first word of "cc", so it can be a program name with args.
3091 set dummy cc; ac_word=$2
3092 echo "$as_me:$LINENO: checking for $ac_word" >&5
3093 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3094 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3095   echo $ECHO_N "(cached) $ECHO_C" >&6
3096 else
3097   if test -n "$ac_ct_CC"; then
3098   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3099 else
3100 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3101 for as_dir in $PATH
3102 do
3103   IFS=$as_save_IFS
3104   test -z "$as_dir" && as_dir=.
3105   for ac_exec_ext in '' $ac_executable_extensions; do
3106   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3107     ac_cv_prog_ac_ct_CC="cc"
3108     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3109     break 2
3110   fi
3111 done
3112 done
3113
3114 fi
3115 fi
3116 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3117 if test -n "$ac_ct_CC"; then
3118   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3119 echo "${ECHO_T}$ac_ct_CC" >&6
3120 else
3121   echo "$as_me:$LINENO: result: no" >&5
3122 echo "${ECHO_T}no" >&6
3123 fi
3124
3125   CC=$ac_ct_CC
3126 else
3127   CC="$ac_cv_prog_CC"
3128 fi
3129
3130 fi
3131 if test -z "$CC"; then
3132   # Extract the first word of "cc", so it can be a program name with args.
3133 set dummy cc; ac_word=$2
3134 echo "$as_me:$LINENO: checking for $ac_word" >&5
3135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3136 if test "${ac_cv_prog_CC+set}" = set; then
3137   echo $ECHO_N "(cached) $ECHO_C" >&6
3138 else
3139   if test -n "$CC"; then
3140   ac_cv_prog_CC="$CC" # Let the user override the test.
3141 else
3142   ac_prog_rejected=no
3143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3144 for as_dir in $PATH
3145 do
3146   IFS=$as_save_IFS
3147   test -z "$as_dir" && as_dir=.
3148   for ac_exec_ext in '' $ac_executable_extensions; do
3149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3150     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3151        ac_prog_rejected=yes
3152        continue
3153      fi
3154     ac_cv_prog_CC="cc"
3155     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3156     break 2
3157   fi
3158 done
3159 done
3160
3161 if test $ac_prog_rejected = yes; then
3162   # We found a bogon in the path, so make sure we never use it.
3163   set dummy $ac_cv_prog_CC
3164   shift
3165   if test $# != 0; then
3166     # We chose a different compiler from the bogus one.
3167     # However, it has the same basename, so the bogon will be chosen
3168     # first if we set CC to just the basename; use the full file name.
3169     shift
3170     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3171   fi
3172 fi
3173 fi
3174 fi
3175 CC=$ac_cv_prog_CC
3176 if test -n "$CC"; then
3177   echo "$as_me:$LINENO: result: $CC" >&5
3178 echo "${ECHO_T}$CC" >&6
3179 else
3180   echo "$as_me:$LINENO: result: no" >&5
3181 echo "${ECHO_T}no" >&6
3182 fi
3183
3184 fi
3185 if test -z "$CC"; then
3186   if test -n "$ac_tool_prefix"; then
3187   for ac_prog in cl
3188   do
3189     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3190 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3191 echo "$as_me:$LINENO: checking for $ac_word" >&5
3192 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3193 if test "${ac_cv_prog_CC+set}" = set; then
3194   echo $ECHO_N "(cached) $ECHO_C" >&6
3195 else
3196   if test -n "$CC"; then
3197   ac_cv_prog_CC="$CC" # Let the user override the test.
3198 else
3199 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3200 for as_dir in $PATH
3201 do
3202   IFS=$as_save_IFS
3203   test -z "$as_dir" && as_dir=.
3204   for ac_exec_ext in '' $ac_executable_extensions; do
3205   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3206     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3207     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3208     break 2
3209   fi
3210 done
3211 done
3212
3213 fi
3214 fi
3215 CC=$ac_cv_prog_CC
3216 if test -n "$CC"; then
3217   echo "$as_me:$LINENO: result: $CC" >&5
3218 echo "${ECHO_T}$CC" >&6
3219 else
3220   echo "$as_me:$LINENO: result: no" >&5
3221 echo "${ECHO_T}no" >&6
3222 fi
3223
3224     test -n "$CC" && break
3225   done
3226 fi
3227 if test -z "$CC"; then
3228   ac_ct_CC=$CC
3229   for ac_prog in cl
3230 do
3231   # Extract the first word of "$ac_prog", so it can be a program name with args.
3232 set dummy $ac_prog; ac_word=$2
3233 echo "$as_me:$LINENO: checking for $ac_word" >&5
3234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3235 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3236   echo $ECHO_N "(cached) $ECHO_C" >&6
3237 else
3238   if test -n "$ac_ct_CC"; then
3239   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3240 else
3241 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3242 for as_dir in $PATH
3243 do
3244   IFS=$as_save_IFS
3245   test -z "$as_dir" && as_dir=.
3246   for ac_exec_ext in '' $ac_executable_extensions; do
3247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3248     ac_cv_prog_ac_ct_CC="$ac_prog"
3249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3250     break 2
3251   fi
3252 done
3253 done
3254
3255 fi
3256 fi
3257 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3258 if test -n "$ac_ct_CC"; then
3259   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3260 echo "${ECHO_T}$ac_ct_CC" >&6
3261 else
3262   echo "$as_me:$LINENO: result: no" >&5
3263 echo "${ECHO_T}no" >&6
3264 fi
3265
3266   test -n "$ac_ct_CC" && break
3267 done
3268
3269   CC=$ac_ct_CC
3270 fi
3271
3272 fi
3273
3274
3275 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3276 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3277 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3278 See \`config.log' for more details." >&5
3279 echo "$as_me: error: no acceptable C compiler found in \$PATH
3280 See \`config.log' for more details." >&2;}
3281    { (exit 1); exit 1; }; }; }
3282
3283 # Provide some information about the compiler.
3284 echo "$as_me:$LINENO:" \
3285      "checking for C compiler version" >&5
3286 ac_compiler=`set X $ac_compile; echo $2`
3287 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3288   (eval $ac_compiler --version </dev/null >&5) 2>&5
3289   ac_status=$?
3290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3291   (exit $ac_status); }
3292 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3293   (eval $ac_compiler -v </dev/null >&5) 2>&5
3294   ac_status=$?
3295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3296   (exit $ac_status); }
3297 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3298   (eval $ac_compiler -V </dev/null >&5) 2>&5
3299   ac_status=$?
3300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3301   (exit $ac_status); }
3302
3303 cat >conftest.$ac_ext <<_ACEOF
3304 /* confdefs.h.  */
3305 _ACEOF
3306 cat confdefs.h >>conftest.$ac_ext
3307 cat >>conftest.$ac_ext <<_ACEOF
3308 /* end confdefs.h.  */
3309
3310 int
3311 main ()
3312 {
3313
3314   ;
3315   return 0;
3316 }
3317 _ACEOF
3318 ac_clean_files_save=$ac_clean_files
3319 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3320 # Try to create an executable without -o first, disregard a.out.
3321 # It will help us diagnose broken compilers, and finding out an intuition
3322 # of exeext.
3323 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3324 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3325 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3326 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3327   (eval $ac_link_default) 2>&5
3328   ac_status=$?
3329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3330   (exit $ac_status); }; then
3331   # Find the output, starting from the most likely.  This scheme is
3332 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3333 # resort.
3334
3335 # Be careful to initialize this variable, since it used to be cached.
3336 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3337 ac_cv_exeext=
3338 # b.out is created by i960 compilers.
3339 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3340 do
3341   test -f "$ac_file" || continue
3342   case $ac_file in
3343     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3344         ;;
3345     conftest.$ac_ext )
3346         # This is the source file.
3347         ;;
3348     [ab].out )
3349         # We found the default executable, but exeext='' is most
3350         # certainly right.
3351         break;;
3352     *.* )
3353         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3354         # FIXME: I believe we export ac_cv_exeext for Libtool,
3355         # but it would be cool to find out if it's true.  Does anybody
3356         # maintain Libtool? --akim.
3357         export ac_cv_exeext
3358         break;;
3359     * )
3360         break;;
3361   esac
3362 done
3363 else
3364   echo "$as_me: failed program was:" >&5
3365 sed 's/^/| /' conftest.$ac_ext >&5
3366
3367 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3368 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3369 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3370 See \`config.log' for more details." >&5
3371 echo "$as_me: error: C compiler cannot create executables
3372 See \`config.log' for more details." >&2;}
3373    { (exit 77); exit 77; }; }; }
3374 fi
3375
3376 ac_exeext=$ac_cv_exeext
3377 echo "$as_me:$LINENO: result: $ac_file" >&5
3378 echo "${ECHO_T}$ac_file" >&6
3379
3380 # Check the compiler produces executables we can run.  If not, either
3381 # the compiler is broken, or we cross compile.
3382 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3383 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3384 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3385 # If not cross compiling, check that we can run a simple program.
3386 if test "$cross_compiling" != yes; then
3387   if { ac_try='./$ac_file'
3388   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3389   (eval $ac_try) 2>&5
3390   ac_status=$?
3391   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3392   (exit $ac_status); }; }; then
3393     cross_compiling=no
3394   else
3395     if test "$cross_compiling" = maybe; then
3396         cross_compiling=yes
3397     else
3398         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3399 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3400 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3401 If you meant to cross compile, use \`--host'.
3402 See \`config.log' for more details." >&5
3403 echo "$as_me: error: cannot run C compiled programs.
3404 If you meant to cross compile, use \`--host'.
3405 See \`config.log' for more details." >&2;}
3406    { (exit 1); exit 1; }; }; }
3407     fi
3408   fi
3409 fi
3410 echo "$as_me:$LINENO: result: yes" >&5
3411 echo "${ECHO_T}yes" >&6
3412
3413 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3414 ac_clean_files=$ac_clean_files_save
3415 # Check the compiler produces executables we can run.  If not, either
3416 # the compiler is broken, or we cross compile.
3417 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3418 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3419 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3420 echo "${ECHO_T}$cross_compiling" >&6
3421
3422 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3423 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3424 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3425   (eval $ac_link) 2>&5
3426   ac_status=$?
3427   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3428   (exit $ac_status); }; then
3429   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3430 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3431 # work properly (i.e., refer to `conftest.exe'), while it won't with
3432 # `rm'.
3433 for ac_file in conftest.exe conftest conftest.*; do
3434   test -f "$ac_file" || continue
3435   case $ac_file in
3436     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3437     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3438           export ac_cv_exeext
3439           break;;
3440     * ) break;;
3441   esac
3442 done
3443 else
3444   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3445 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3446 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3447 See \`config.log' for more details." >&5
3448 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3449 See \`config.log' for more details." >&2;}
3450    { (exit 1); exit 1; }; }; }
3451 fi
3452
3453 rm -f conftest$ac_cv_exeext
3454 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3455 echo "${ECHO_T}$ac_cv_exeext" >&6
3456
3457 rm -f conftest.$ac_ext
3458 EXEEXT=$ac_cv_exeext
3459 ac_exeext=$EXEEXT
3460 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3461 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3462 if test "${ac_cv_objext+set}" = set; then
3463   echo $ECHO_N "(cached) $ECHO_C" >&6
3464 else
3465   cat >conftest.$ac_ext <<_ACEOF
3466 /* confdefs.h.  */
3467 _ACEOF
3468 cat confdefs.h >>conftest.$ac_ext
3469 cat >>conftest.$ac_ext <<_ACEOF
3470 /* end confdefs.h.  */
3471
3472 int
3473 main ()
3474 {
3475
3476   ;
3477   return 0;
3478 }
3479 _ACEOF
3480 rm -f conftest.o conftest.obj
3481 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3482   (eval $ac_compile) 2>&5
3483   ac_status=$?
3484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3485   (exit $ac_status); }; then
3486   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3487   case $ac_file in
3488     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3489     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3490        break;;
3491   esac
3492 done
3493 else
3494   echo "$as_me: failed program was:" >&5
3495 sed 's/^/| /' conftest.$ac_ext >&5
3496
3497 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3498 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3499 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3500 See \`config.log' for more details." >&5
3501 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3502 See \`config.log' for more details." >&2;}
3503    { (exit 1); exit 1; }; }; }
3504 fi
3505
3506 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3507 fi
3508 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3509 echo "${ECHO_T}$ac_cv_objext" >&6
3510 OBJEXT=$ac_cv_objext
3511 ac_objext=$OBJEXT
3512 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3513 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3514 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3515   echo $ECHO_N "(cached) $ECHO_C" >&6
3516 else
3517   cat >conftest.$ac_ext <<_ACEOF
3518 /* confdefs.h.  */
3519 _ACEOF
3520 cat confdefs.h >>conftest.$ac_ext
3521 cat >>conftest.$ac_ext <<_ACEOF
3522 /* end confdefs.h.  */
3523
3524 int
3525 main ()
3526 {
3527 #ifndef __GNUC__
3528        choke me
3529 #endif
3530
3531   ;
3532   return 0;
3533 }
3534 _ACEOF
3535 rm -f conftest.$ac_objext
3536 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3537   (eval $ac_compile) 2>conftest.er1
3538   ac_status=$?
3539   grep -v '^ *+' conftest.er1 >conftest.err
3540   rm -f conftest.er1
3541   cat conftest.err >&5
3542   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3543   (exit $ac_status); } &&
3544          { ac_try='test -z "$ac_c_werror_flag"
3545                          || test ! -s conftest.err'
3546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3547   (eval $ac_try) 2>&5
3548   ac_status=$?
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); }; } &&
3551          { ac_try='test -s conftest.$ac_objext'
3552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3553   (eval $ac_try) 2>&5
3554   ac_status=$?
3555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556   (exit $ac_status); }; }; then
3557   ac_compiler_gnu=yes
3558 else
3559   echo "$as_me: failed program was:" >&5
3560 sed 's/^/| /' conftest.$ac_ext >&5
3561
3562 ac_compiler_gnu=no
3563 fi
3564 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3565 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3566
3567 fi
3568 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3569 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3570 GCC=`test $ac_compiler_gnu = yes && echo yes`
3571 ac_test_CFLAGS=${CFLAGS+set}
3572 ac_save_CFLAGS=$CFLAGS
3573 CFLAGS="-g"
3574 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3575 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3576 if test "${ac_cv_prog_cc_g+set}" = set; then
3577   echo $ECHO_N "(cached) $ECHO_C" >&6
3578 else
3579   cat >conftest.$ac_ext <<_ACEOF
3580 /* confdefs.h.  */
3581 _ACEOF
3582 cat confdefs.h >>conftest.$ac_ext
3583 cat >>conftest.$ac_ext <<_ACEOF
3584 /* end confdefs.h.  */
3585
3586 int
3587 main ()
3588 {
3589
3590   ;
3591   return 0;
3592 }
3593 _ACEOF
3594 rm -f conftest.$ac_objext
3595 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3596   (eval $ac_compile) 2>conftest.er1
3597   ac_status=$?
3598   grep -v '^ *+' conftest.er1 >conftest.err
3599   rm -f conftest.er1
3600   cat conftest.err >&5
3601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3602   (exit $ac_status); } &&
3603          { ac_try='test -z "$ac_c_werror_flag"
3604                          || test ! -s conftest.err'
3605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3606   (eval $ac_try) 2>&5
3607   ac_status=$?
3608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3609   (exit $ac_status); }; } &&
3610          { ac_try='test -s conftest.$ac_objext'
3611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3612   (eval $ac_try) 2>&5
3613   ac_status=$?
3614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3615   (exit $ac_status); }; }; then
3616   ac_cv_prog_cc_g=yes
3617 else
3618   echo "$as_me: failed program was:" >&5
3619 sed 's/^/| /' conftest.$ac_ext >&5
3620
3621 ac_cv_prog_cc_g=no
3622 fi
3623 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3624 fi
3625 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3626 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3627 if test "$ac_test_CFLAGS" = set; then
3628   CFLAGS=$ac_save_CFLAGS
3629 elif test $ac_cv_prog_cc_g = yes; then
3630   if test "$GCC" = yes; then
3631     CFLAGS="-g -O2"
3632   else
3633     CFLAGS="-g"
3634   fi
3635 else
3636   if test "$GCC" = yes; then
3637     CFLAGS="-O2"
3638   else
3639     CFLAGS=
3640   fi
3641 fi
3642 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3643 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3644 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3645   echo $ECHO_N "(cached) $ECHO_C" >&6
3646 else
3647   ac_cv_prog_cc_stdc=no
3648 ac_save_CC=$CC
3649 cat >conftest.$ac_ext <<_ACEOF
3650 /* confdefs.h.  */
3651 _ACEOF
3652 cat confdefs.h >>conftest.$ac_ext
3653 cat >>conftest.$ac_ext <<_ACEOF
3654 /* end confdefs.h.  */
3655 #include <stdarg.h>
3656 #include <stdio.h>
3657 #include <sys/types.h>
3658 #include <sys/stat.h>
3659 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3660 struct buf { int x; };
3661 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3662 static char *e (p, i)
3663      char **p;
3664      int i;
3665 {
3666   return p[i];
3667 }
3668 static char *f (char * (*g) (char **, int), char **p, ...)
3669 {
3670   char *s;
3671   va_list v;
3672   va_start (v,p);
3673   s = g (p, va_arg (v,int));
3674   va_end (v);
3675   return s;
3676 }
3677
3678 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3679    function prototypes and stuff, but not '\xHH' hex character constants.
3680    These don't provoke an error unfortunately, instead are silently treated
3681    as 'x'.  The following induces an error, until -std1 is added to get
3682    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3683    array size at least.  It's necessary to write '\x00'==0 to get something
3684    that's true only with -std1.  */
3685 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3686
3687 int test (int i, double x);
3688 struct s1 {int (*f) (int a);};
3689 struct s2 {int (*f) (double a);};
3690 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3691 int argc;
3692 char **argv;
3693 int
3694 main ()
3695 {
3696 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3697   ;
3698   return 0;
3699 }
3700 _ACEOF
3701 # Don't try gcc -ansi; that turns off useful extensions and
3702 # breaks some systems' header files.
3703 # AIX                   -qlanglvl=ansi
3704 # Ultrix and OSF/1      -std1
3705 # HP-UX 10.20 and later -Ae
3706 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3707 # SVR4                  -Xc -D__EXTENSIONS__
3708 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3709 do
3710   CC="$ac_save_CC $ac_arg"
3711   rm -f conftest.$ac_objext
3712 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3713   (eval $ac_compile) 2>conftest.er1
3714   ac_status=$?
3715   grep -v '^ *+' conftest.er1 >conftest.err
3716   rm -f conftest.er1
3717   cat conftest.err >&5
3718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3719   (exit $ac_status); } &&
3720          { ac_try='test -z "$ac_c_werror_flag"
3721                          || test ! -s conftest.err'
3722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3723   (eval $ac_try) 2>&5
3724   ac_status=$?
3725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3726   (exit $ac_status); }; } &&
3727          { ac_try='test -s conftest.$ac_objext'
3728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3729   (eval $ac_try) 2>&5
3730   ac_status=$?
3731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3732   (exit $ac_status); }; }; then
3733   ac_cv_prog_cc_stdc=$ac_arg
3734 break
3735 else
3736   echo "$as_me: failed program was:" >&5
3737 sed 's/^/| /' conftest.$ac_ext >&5
3738
3739 fi
3740 rm -f conftest.err conftest.$ac_objext
3741 done
3742 rm -f conftest.$ac_ext conftest.$ac_objext
3743 CC=$ac_save_CC
3744
3745 fi
3746
3747 case "x$ac_cv_prog_cc_stdc" in
3748   x|xno)
3749     echo "$as_me:$LINENO: result: none needed" >&5
3750 echo "${ECHO_T}none needed" >&6 ;;
3751   *)
3752     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3753 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3754     CC="$CC $ac_cv_prog_cc_stdc" ;;
3755 esac
3756
3757 # Some people use a C++ compiler to compile C.  Since we use `exit',
3758 # in C++ we need to declare it.  In case someone uses the same compiler
3759 # for both compiling C and C++ we need to have the C++ compiler decide
3760 # the declaration of exit, since it's the most demanding environment.
3761 cat >conftest.$ac_ext <<_ACEOF
3762 #ifndef __cplusplus
3763   choke me
3764 #endif
3765 _ACEOF
3766 rm -f conftest.$ac_objext
3767 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3768   (eval $ac_compile) 2>conftest.er1
3769   ac_status=$?
3770   grep -v '^ *+' conftest.er1 >conftest.err
3771   rm -f conftest.er1
3772   cat conftest.err >&5
3773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3774   (exit $ac_status); } &&
3775          { ac_try='test -z "$ac_c_werror_flag"
3776                          || test ! -s conftest.err'
3777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3778   (eval $ac_try) 2>&5
3779   ac_status=$?
3780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3781   (exit $ac_status); }; } &&
3782          { ac_try='test -s conftest.$ac_objext'
3783   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3784   (eval $ac_try) 2>&5
3785   ac_status=$?
3786   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3787   (exit $ac_status); }; }; then
3788   for ac_declaration in \
3789    '' \
3790    'extern "C" void std::exit (int) throw (); using std::exit;' \
3791    'extern "C" void std::exit (int); using std::exit;' \
3792    'extern "C" void exit (int) throw ();' \
3793    'extern "C" void exit (int);' \
3794    'void exit (int);'
3795 do
3796   cat >conftest.$ac_ext <<_ACEOF
3797 /* confdefs.h.  */
3798 _ACEOF
3799 cat confdefs.h >>conftest.$ac_ext
3800 cat >>conftest.$ac_ext <<_ACEOF
3801 /* end confdefs.h.  */
3802 $ac_declaration
3803 #include <stdlib.h>
3804 int
3805 main ()
3806 {
3807 exit (42);
3808   ;
3809   return 0;
3810 }
3811 _ACEOF
3812 rm -f conftest.$ac_objext
3813 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3814   (eval $ac_compile) 2>conftest.er1
3815   ac_status=$?
3816   grep -v '^ *+' conftest.er1 >conftest.err
3817   rm -f conftest.er1
3818   cat conftest.err >&5
3819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3820   (exit $ac_status); } &&
3821          { ac_try='test -z "$ac_c_werror_flag"
3822                          || test ! -s conftest.err'
3823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3824   (eval $ac_try) 2>&5
3825   ac_status=$?
3826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3827   (exit $ac_status); }; } &&
3828          { ac_try='test -s conftest.$ac_objext'
3829   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3830   (eval $ac_try) 2>&5
3831   ac_status=$?
3832   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3833   (exit $ac_status); }; }; then
3834   :
3835 else
3836   echo "$as_me: failed program was:" >&5
3837 sed 's/^/| /' conftest.$ac_ext >&5
3838
3839 continue
3840 fi
3841 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3842   cat >conftest.$ac_ext <<_ACEOF
3843 /* confdefs.h.  */
3844 _ACEOF
3845 cat confdefs.h >>conftest.$ac_ext
3846 cat >>conftest.$ac_ext <<_ACEOF
3847 /* end confdefs.h.  */
3848 $ac_declaration
3849 int
3850 main ()
3851 {
3852 exit (42);
3853   ;
3854   return 0;
3855 }
3856 _ACEOF
3857 rm -f conftest.$ac_objext
3858 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3859   (eval $ac_compile) 2>conftest.er1
3860   ac_status=$?
3861   grep -v '^ *+' conftest.er1 >conftest.err
3862   rm -f conftest.er1
3863   cat conftest.err >&5
3864   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3865   (exit $ac_status); } &&
3866          { ac_try='test -z "$ac_c_werror_flag"
3867                          || test ! -s conftest.err'
3868   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3869   (eval $ac_try) 2>&5
3870   ac_status=$?
3871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3872   (exit $ac_status); }; } &&
3873          { ac_try='test -s conftest.$ac_objext'
3874   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3875   (eval $ac_try) 2>&5
3876   ac_status=$?
3877   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3878   (exit $ac_status); }; }; then
3879   break
3880 else
3881   echo "$as_me: failed program was:" >&5
3882 sed 's/^/| /' conftest.$ac_ext >&5
3883
3884 fi
3885 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3886 done
3887 rm -f conftest*
3888 if test -n "$ac_declaration"; then
3889   echo '#ifdef __cplusplus' >>confdefs.h
3890   echo $ac_declaration      >>confdefs.h
3891   echo '#endif'             >>confdefs.h
3892 fi
3893
3894 else
3895   echo "$as_me: failed program was:" >&5
3896 sed 's/^/| /' conftest.$ac_ext >&5
3897
3898 fi
3899 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3900 ac_ext=c
3901 ac_cpp='$CPP $CPPFLAGS'
3902 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3903 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3904 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3905
3906 ac_ext=cc
3907 ac_cpp='$CXXCPP $CPPFLAGS'
3908 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3909 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3910 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3911 if test -n "$ac_tool_prefix"; then
3912   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3913   do
3914     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3915 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3916 echo "$as_me:$LINENO: checking for $ac_word" >&5
3917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3918 if test "${ac_cv_prog_CXX+set}" = set; then
3919   echo $ECHO_N "(cached) $ECHO_C" >&6
3920 else
3921   if test -n "$CXX"; then
3922   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3923 else
3924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3925 for as_dir in $PATH
3926 do
3927   IFS=$as_save_IFS
3928   test -z "$as_dir" && as_dir=.
3929   for ac_exec_ext in '' $ac_executable_extensions; do
3930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3931     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3933     break 2
3934   fi
3935 done
3936 done
3937
3938 fi
3939 fi
3940 CXX=$ac_cv_prog_CXX
3941 if test -n "$CXX"; then
3942   echo "$as_me:$LINENO: result: $CXX" >&5
3943 echo "${ECHO_T}$CXX" >&6
3944 else
3945   echo "$as_me:$LINENO: result: no" >&5
3946 echo "${ECHO_T}no" >&6
3947 fi
3948
3949     test -n "$CXX" && break
3950   done
3951 fi
3952 if test -z "$CXX"; then
3953   ac_ct_CXX=$CXX
3954   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3955 do
3956   # Extract the first word of "$ac_prog", so it can be a program name with args.
3957 set dummy $ac_prog; ac_word=$2
3958 echo "$as_me:$LINENO: checking for $ac_word" >&5
3959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3960 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3961   echo $ECHO_N "(cached) $ECHO_C" >&6
3962 else
3963   if test -n "$ac_ct_CXX"; then
3964   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3965 else
3966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3967 for as_dir in $PATH
3968 do
3969   IFS=$as_save_IFS
3970   test -z "$as_dir" && as_dir=.
3971   for ac_exec_ext in '' $ac_executable_extensions; do
3972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3973     ac_cv_prog_ac_ct_CXX="$ac_prog"
3974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3975     break 2
3976   fi
3977 done
3978 done
3979
3980 fi
3981 fi
3982 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3983 if test -n "$ac_ct_CXX"; then
3984   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3985 echo "${ECHO_T}$ac_ct_CXX" >&6
3986 else
3987   echo "$as_me:$LINENO: result: no" >&5
3988 echo "${ECHO_T}no" >&6
3989 fi
3990
3991   test -n "$ac_ct_CXX" && break
3992 done
3993 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3994
3995   CXX=$ac_ct_CXX
3996 fi
3997
3998
3999 # Provide some information about the compiler.
4000 echo "$as_me:$LINENO:" \
4001      "checking for C++ compiler version" >&5
4002 ac_compiler=`set X $ac_compile; echo $2`
4003 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4004   (eval $ac_compiler --version </dev/null >&5) 2>&5
4005   ac_status=$?
4006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007   (exit $ac_status); }
4008 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4009   (eval $ac_compiler -v </dev/null >&5) 2>&5
4010   ac_status=$?
4011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4012   (exit $ac_status); }
4013 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4014   (eval $ac_compiler -V </dev/null >&5) 2>&5
4015   ac_status=$?
4016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4017   (exit $ac_status); }
4018
4019 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4020 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4021 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4022   echo $ECHO_N "(cached) $ECHO_C" >&6
4023 else
4024   cat >conftest.$ac_ext <<_ACEOF
4025 /* confdefs.h.  */
4026 _ACEOF
4027 cat confdefs.h >>conftest.$ac_ext
4028 cat >>conftest.$ac_ext <<_ACEOF
4029 /* end confdefs.h.  */
4030
4031 int
4032 main ()
4033 {
4034 #ifndef __GNUC__
4035        choke me
4036 #endif
4037
4038   ;
4039   return 0;
4040 }
4041 _ACEOF
4042 rm -f conftest.$ac_objext
4043 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4044   (eval $ac_compile) 2>conftest.er1
4045   ac_status=$?
4046   grep -v '^ *+' conftest.er1 >conftest.err
4047   rm -f conftest.er1
4048   cat conftest.err >&5
4049   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4050   (exit $ac_status); } &&
4051          { ac_try='test -z "$ac_cxx_werror_flag"
4052                          || test ! -s conftest.err'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; } &&
4058          { ac_try='test -s conftest.$ac_objext'
4059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4060   (eval $ac_try) 2>&5
4061   ac_status=$?
4062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4063   (exit $ac_status); }; }; then
4064   ac_compiler_gnu=yes
4065 else
4066   echo "$as_me: failed program was:" >&5
4067 sed 's/^/| /' conftest.$ac_ext >&5
4068
4069 ac_compiler_gnu=no
4070 fi
4071 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4072 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4073
4074 fi
4075 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4076 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4077 GXX=`test $ac_compiler_gnu = yes && echo yes`
4078 ac_test_CXXFLAGS=${CXXFLAGS+set}
4079 ac_save_CXXFLAGS=$CXXFLAGS
4080 CXXFLAGS="-g"
4081 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4082 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4083 if test "${ac_cv_prog_cxx_g+set}" = set; then
4084   echo $ECHO_N "(cached) $ECHO_C" >&6
4085 else
4086   cat >conftest.$ac_ext <<_ACEOF
4087 /* confdefs.h.  */
4088 _ACEOF
4089 cat confdefs.h >>conftest.$ac_ext
4090 cat >>conftest.$ac_ext <<_ACEOF
4091 /* end confdefs.h.  */
4092
4093 int
4094 main ()
4095 {
4096
4097   ;
4098   return 0;
4099 }
4100 _ACEOF
4101 rm -f conftest.$ac_objext
4102 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4103   (eval $ac_compile) 2>conftest.er1
4104   ac_status=$?
4105   grep -v '^ *+' conftest.er1 >conftest.err
4106   rm -f conftest.er1
4107   cat conftest.err >&5
4108   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4109   (exit $ac_status); } &&
4110          { ac_try='test -z "$ac_cxx_werror_flag"
4111                          || test ! -s conftest.err'
4112   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4113   (eval $ac_try) 2>&5
4114   ac_status=$?
4115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4116   (exit $ac_status); }; } &&
4117          { ac_try='test -s conftest.$ac_objext'
4118   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4119   (eval $ac_try) 2>&5
4120   ac_status=$?
4121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4122   (exit $ac_status); }; }; then
4123   ac_cv_prog_cxx_g=yes
4124 else
4125   echo "$as_me: failed program was:" >&5
4126 sed 's/^/| /' conftest.$ac_ext >&5
4127
4128 ac_cv_prog_cxx_g=no
4129 fi
4130 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4131 fi
4132 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4133 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4134 if test "$ac_test_CXXFLAGS" = set; then
4135   CXXFLAGS=$ac_save_CXXFLAGS
4136 elif test $ac_cv_prog_cxx_g = yes; then
4137   if test "$GXX" = yes; then
4138     CXXFLAGS="-g -O2"
4139   else
4140     CXXFLAGS="-g"
4141   fi
4142 else
4143   if test "$GXX" = yes; then
4144     CXXFLAGS="-O2"
4145   else
4146     CXXFLAGS=
4147   fi
4148 fi
4149 for ac_declaration in \
4150    '' \
4151    'extern "C" void std::exit (int) throw (); using std::exit;' \
4152    'extern "C" void std::exit (int); using std::exit;' \
4153    'extern "C" void exit (int) throw ();' \
4154    'extern "C" void exit (int);' \
4155    'void exit (int);'
4156 do
4157   cat >conftest.$ac_ext <<_ACEOF
4158 /* confdefs.h.  */
4159 _ACEOF
4160 cat confdefs.h >>conftest.$ac_ext
4161 cat >>conftest.$ac_ext <<_ACEOF
4162 /* end confdefs.h.  */
4163 $ac_declaration
4164 #include <stdlib.h>
4165 int
4166 main ()
4167 {
4168 exit (42);
4169   ;
4170   return 0;
4171 }
4172 _ACEOF
4173 rm -f conftest.$ac_objext
4174 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4175   (eval $ac_compile) 2>conftest.er1
4176   ac_status=$?
4177   grep -v '^ *+' conftest.er1 >conftest.err
4178   rm -f conftest.er1
4179   cat conftest.err >&5
4180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4181   (exit $ac_status); } &&
4182          { ac_try='test -z "$ac_cxx_werror_flag"
4183                          || test ! -s conftest.err'
4184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4185   (eval $ac_try) 2>&5
4186   ac_status=$?
4187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4188   (exit $ac_status); }; } &&
4189          { ac_try='test -s conftest.$ac_objext'
4190   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4191   (eval $ac_try) 2>&5
4192   ac_status=$?
4193   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4194   (exit $ac_status); }; }; then
4195   :
4196 else
4197   echo "$as_me: failed program was:" >&5
4198 sed 's/^/| /' conftest.$ac_ext >&5
4199
4200 continue
4201 fi
4202 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4203   cat >conftest.$ac_ext <<_ACEOF
4204 /* confdefs.h.  */
4205 _ACEOF
4206 cat confdefs.h >>conftest.$ac_ext
4207 cat >>conftest.$ac_ext <<_ACEOF
4208 /* end confdefs.h.  */
4209 $ac_declaration
4210 int
4211 main ()
4212 {
4213 exit (42);
4214   ;
4215   return 0;
4216 }
4217 _ACEOF
4218 rm -f conftest.$ac_objext
4219 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4220   (eval $ac_compile) 2>conftest.er1
4221   ac_status=$?
4222   grep -v '^ *+' conftest.er1 >conftest.err
4223   rm -f conftest.er1
4224   cat conftest.err >&5
4225   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4226   (exit $ac_status); } &&
4227          { ac_try='test -z "$ac_cxx_werror_flag"
4228                          || test ! -s conftest.err'
4229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4230   (eval $ac_try) 2>&5
4231   ac_status=$?
4232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4233   (exit $ac_status); }; } &&
4234          { ac_try='test -s conftest.$ac_objext'
4235   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4236   (eval $ac_try) 2>&5
4237   ac_status=$?
4238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4239   (exit $ac_status); }; }; then
4240   break
4241 else
4242   echo "$as_me: failed program was:" >&5
4243 sed 's/^/| /' conftest.$ac_ext >&5
4244
4245 fi
4246 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4247 done
4248 rm -f conftest*
4249 if test -n "$ac_declaration"; then
4250   echo '#ifdef __cplusplus' >>confdefs.h
4251   echo $ac_declaration      >>confdefs.h
4252   echo '#endif'             >>confdefs.h
4253 fi
4254
4255 ac_ext=c
4256 ac_cpp='$CPP $CPPFLAGS'
4257 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4258 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4259 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4260
4261
4262 # We must set the default linker to the linker used by gcc for the correct
4263 # operation of libtool.  If LD is not defined and we are using gcc, try to
4264 # set the LD default to the ld used by gcc.
4265 if test -z "$LD"; then
4266   if test "$GCC" = yes; then
4267     case $build in
4268     *-*-mingw*)
4269       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4270     *)
4271       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4272     esac
4273     case $gcc_prog_ld in
4274     # Accept absolute paths.
4275     [\\/]* | [A-Za-z]:[\\/]*)
4276       LD="$gcc_prog_ld" ;;
4277     esac
4278   fi
4279 fi
4280
4281
4282
4283
4284 if test -n "$ac_tool_prefix"; then
4285   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4286 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4287 echo "$as_me:$LINENO: checking for $ac_word" >&5
4288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4289 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4290   echo $ECHO_N "(cached) $ECHO_C" >&6
4291 else
4292   if test -n "$GNATBIND"; then
4293   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4294 else
4295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4296 for as_dir in $PATH
4297 do
4298   IFS=$as_save_IFS
4299   test -z "$as_dir" && as_dir=.
4300   for ac_exec_ext in '' $ac_executable_extensions; do
4301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4302     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4304     break 2
4305   fi
4306 done
4307 done
4308
4309 fi
4310 fi
4311 GNATBIND=$ac_cv_prog_GNATBIND
4312 if test -n "$GNATBIND"; then
4313   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4314 echo "${ECHO_T}$GNATBIND" >&6
4315 else
4316   echo "$as_me:$LINENO: result: no" >&5
4317 echo "${ECHO_T}no" >&6
4318 fi
4319
4320 fi
4321 if test -z "$ac_cv_prog_GNATBIND"; then
4322   ac_ct_GNATBIND=$GNATBIND
4323   # Extract the first word of "gnatbind", so it can be a program name with args.
4324 set dummy gnatbind; ac_word=$2
4325 echo "$as_me:$LINENO: checking for $ac_word" >&5
4326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4327 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4328   echo $ECHO_N "(cached) $ECHO_C" >&6
4329 else
4330   if test -n "$ac_ct_GNATBIND"; then
4331   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4332 else
4333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4334 for as_dir in $PATH
4335 do
4336   IFS=$as_save_IFS
4337   test -z "$as_dir" && as_dir=.
4338   for ac_exec_ext in '' $ac_executable_extensions; do
4339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4340     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4342     break 2
4343   fi
4344 done
4345 done
4346
4347   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4348 fi
4349 fi
4350 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4351 if test -n "$ac_ct_GNATBIND"; then
4352   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4353 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4354 else
4355   echo "$as_me:$LINENO: result: no" >&5
4356 echo "${ECHO_T}no" >&6
4357 fi
4358
4359   GNATBIND=$ac_ct_GNATBIND
4360 else
4361   GNATBIND="$ac_cv_prog_GNATBIND"
4362 fi
4363
4364 if test -n "$ac_tool_prefix"; then
4365   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4366 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4367 echo "$as_me:$LINENO: checking for $ac_word" >&5
4368 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4369 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4370   echo $ECHO_N "(cached) $ECHO_C" >&6
4371 else
4372   if test -n "$GNATMAKE"; then
4373   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4374 else
4375 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4376 for as_dir in $PATH
4377 do
4378   IFS=$as_save_IFS
4379   test -z "$as_dir" && as_dir=.
4380   for ac_exec_ext in '' $ac_executable_extensions; do
4381   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4382     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4383     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4384     break 2
4385   fi
4386 done
4387 done
4388
4389 fi
4390 fi
4391 GNATMAKE=$ac_cv_prog_GNATMAKE
4392 if test -n "$GNATMAKE"; then
4393   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4394 echo "${ECHO_T}$GNATMAKE" >&6
4395 else
4396   echo "$as_me:$LINENO: result: no" >&5
4397 echo "${ECHO_T}no" >&6
4398 fi
4399
4400 fi
4401 if test -z "$ac_cv_prog_GNATMAKE"; then
4402   ac_ct_GNATMAKE=$GNATMAKE
4403   # Extract the first word of "gnatmake", so it can be a program name with args.
4404 set dummy gnatmake; ac_word=$2
4405 echo "$as_me:$LINENO: checking for $ac_word" >&5
4406 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4407 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4408   echo $ECHO_N "(cached) $ECHO_C" >&6
4409 else
4410   if test -n "$ac_ct_GNATMAKE"; then
4411   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4412 else
4413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4414 for as_dir in $PATH
4415 do
4416   IFS=$as_save_IFS
4417   test -z "$as_dir" && as_dir=.
4418   for ac_exec_ext in '' $ac_executable_extensions; do
4419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4420     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4422     break 2
4423   fi
4424 done
4425 done
4426
4427   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4428 fi
4429 fi
4430 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4431 if test -n "$ac_ct_GNATMAKE"; then
4432   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4433 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4434 else
4435   echo "$as_me:$LINENO: result: no" >&5
4436 echo "${ECHO_T}no" >&6
4437 fi
4438
4439   GNATMAKE=$ac_ct_GNATMAKE
4440 else
4441   GNATMAKE="$ac_cv_prog_GNATMAKE"
4442 fi
4443
4444 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4445 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4446 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4447   echo $ECHO_N "(cached) $ECHO_C" >&6
4448 else
4449   cat >conftest.adb <<EOF
4450 procedure conftest is begin null; end conftest;
4451 EOF
4452 acx_cv_cc_gcc_supports_ada=no
4453 # There is a bug in old released versions of GCC which causes the
4454 # driver to exit successfully when the appropriate language module
4455 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4456 # Therefore we must check for the error message as well as an
4457 # unsuccessful exit.
4458 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4459 # given a .adb file, but produce no object file.  So we must check
4460 # if an object file was really produced to guard against this.
4461 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4462 if test x"$errors" = x && test -f conftest.$ac_objext; then
4463   acx_cv_cc_gcc_supports_ada=yes
4464 fi
4465 rm -f conftest.*
4466 fi
4467 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4468 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4469
4470 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4471   have_gnat=yes
4472 else
4473   have_gnat=no
4474 fi
4475
4476 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4477 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4478 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4479   echo $ECHO_N "(cached) $ECHO_C" >&6
4480 else
4481    echo abfoo >t1
4482   echo cdfoo >t2
4483   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4484   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4485     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4486       :
4487     else
4488       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4489     fi
4490   fi
4491   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4492     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4493       :
4494     else
4495       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4496     fi
4497   fi
4498   rm t1 t2
4499
4500 fi
4501 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4502 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4503 do_compare="$gcc_cv_prog_cmp_skip"
4504
4505
4506
4507 # Check for GMP, MPFR and MPC
4508 gmplibs="-lmpfr -lgmp"
4509 gmpinc=
4510 have_gmp=no
4511 mpclibs=
4512 mpcinc=
4513 have_mpc=no
4514
4515 # Specify a location for mpc
4516 # check for this first so it ends up on the link line before mpfr.
4517
4518 # Check whether --with-mpc or --without-mpc was given.
4519 if test "${with_mpc+set}" = set; then
4520   withval="$with_mpc"
4521
4522 fi;
4523
4524 # Check whether --with-mpc_include or --without-mpc_include was given.
4525 if test "${with_mpc_include+set}" = set; then
4526   withval="$with_mpc_include"
4527
4528 fi;
4529
4530 # Check whether --with-mpc_lib or --without-mpc_lib was given.
4531 if test "${with_mpc_lib+set}" = set; then
4532   withval="$with_mpc_lib"
4533
4534 fi;
4535
4536 if test "x$with_mpc" != x; then
4537   mpclibs="-L$with_mpc/lib -lmpc"
4538   mpcinc="-I$with_mpc/include $mpcinc"
4539 fi
4540 if test "x$with_mpc_include" != x; then
4541   mpcinc="-I$with_mpc_include $mpcinc"
4542 fi
4543 if test "x$with_mpc_lib" != x; then
4544   mpclibs="-L$with_mpc_lib -lmpc"
4545 fi
4546 if test "x$with_mpc$with_mpc_include$with_mpc_lib" = x && test -d ${srcdir}/mpc; then
4547   mpclibs='-L$$r/$(HOST_SUBDIR)/mpc/src/.libs -L$$r/$(HOST_SUBDIR)/mpc/src/_libs -lmpc'
4548   mpcinc='-I$$s/mpc/src '"$mpcinc"
4549   # Do not test the mpc version.  Assume that it is sufficient, since
4550   # it is in the source tree, and the library has not been built yet
4551   # but it would be included on the link line in the version check below
4552   # hence making the test fail.
4553   have_mpc=yes
4554 fi
4555
4556 # Specify a location for mpfr
4557 # check for this first so it ends up on the link line before gmp.
4558
4559 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4560 if test "${with_mpfr_dir+set}" = set; then
4561   withval="$with_mpfr_dir"
4562   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4563 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4564 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4565 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4566    { (exit 1); exit 1; }; }
4567 fi;
4568
4569
4570 # Check whether --with-mpfr or --without-mpfr was given.
4571 if test "${with_mpfr+set}" = set; then
4572   withval="$with_mpfr"
4573
4574 fi;
4575
4576 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4577 if test "${with_mpfr_include+set}" = set; then
4578   withval="$with_mpfr_include"
4579
4580 fi;
4581
4582 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4583 if test "${with_mpfr_lib+set}" = set; then
4584   withval="$with_mpfr_lib"
4585
4586 fi;
4587
4588 if test "x$with_mpfr" != x; then
4589   gmplibs="-L$with_mpfr/lib $gmplibs"
4590   gmpinc="-I$with_mpfr/include"
4591 fi
4592 if test "x$with_mpfr_include" != x; then
4593   gmpinc="-I$with_mpfr_include"
4594 fi
4595 if test "x$with_mpfr_lib" != x; then
4596   gmplibs="-L$with_mpfr_lib $gmplibs"
4597 fi
4598 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4599   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4600   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4601   extra_mpc_mpfr_configure_flags='--with-mpfr-include=$$s/mpfr'
4602   # Do not test the mpfr version.  Assume that it is sufficient, since
4603   # it is in the source tree, and the library has not been built yet
4604   # but it would be included on the link line in the version check below
4605   # hence making the test fail.
4606   have_gmp=yes
4607 fi
4608
4609 # Specify a location for gmp
4610
4611 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4612 if test "${with_gmp_dir+set}" = set; then
4613   withval="$with_gmp_dir"
4614   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4615 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4616 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4617 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4618    { (exit 1); exit 1; }; }
4619 fi;
4620
4621
4622 # Check whether --with-gmp or --without-gmp was given.
4623 if test "${with_gmp+set}" = set; then
4624   withval="$with_gmp"
4625
4626 fi;
4627
4628 # Check whether --with-gmp_include or --without-gmp_include was given.
4629 if test "${with_gmp_include+set}" = set; then
4630   withval="$with_gmp_include"
4631
4632 fi;
4633
4634 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4635 if test "${with_gmp_lib+set}" = set; then
4636   withval="$with_gmp_lib"
4637
4638 fi;
4639
4640
4641 if test "x$with_gmp" != x; then
4642   gmplibs="-L$with_gmp/lib $gmplibs"
4643   gmpinc="-I$with_gmp/include $gmpinc"
4644 fi
4645 if test "x$with_gmp_include" != x; then
4646   gmpinc="-I$with_gmp_include $gmpinc"
4647 fi
4648 if test "x$with_gmp_lib" != x; then
4649   gmplibs="-L$with_gmp_lib $gmplibs"
4650 fi
4651 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4652   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4653   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4654   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4655   extra_mpc_gmp_configure_flags='--with-gmp-include=$$r/$(HOST_SUBDIR)/gmp'
4656   # Do not test the gmp version.  Assume that it is sufficient, since
4657   # it is in the source tree, and the library has not been built yet
4658   # but it would be included on the link line in the version check below
4659   # hence making the test fail.
4660   have_gmp=yes
4661 fi
4662
4663 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4664   have_gmp=yes
4665   saved_CFLAGS="$CFLAGS"
4666   CFLAGS="$CFLAGS $gmpinc"
4667   # Check GMP actually works
4668   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4669 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4670
4671 cat >conftest.$ac_ext <<_ACEOF
4672 /* confdefs.h.  */
4673 _ACEOF
4674 cat confdefs.h >>conftest.$ac_ext
4675 cat >>conftest.$ac_ext <<_ACEOF
4676 /* end confdefs.h.  */
4677 #include "gmp.h"
4678 int
4679 main ()
4680 {
4681
4682   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4683   choke me
4684   #endif
4685
4686   ;
4687   return 0;
4688 }
4689 _ACEOF
4690 rm -f conftest.$ac_objext
4691 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4692   (eval $ac_compile) 2>conftest.er1
4693   ac_status=$?
4694   grep -v '^ *+' conftest.er1 >conftest.err
4695   rm -f conftest.er1
4696   cat conftest.err >&5
4697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698   (exit $ac_status); } &&
4699          { ac_try='test -z "$ac_c_werror_flag"
4700                          || test ! -s conftest.err'
4701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4702   (eval $ac_try) 2>&5
4703   ac_status=$?
4704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4705   (exit $ac_status); }; } &&
4706          { ac_try='test -s conftest.$ac_objext'
4707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4708   (eval $ac_try) 2>&5
4709   ac_status=$?
4710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4711   (exit $ac_status); }; }; then
4712   echo "$as_me:$LINENO: result: yes" >&5
4713 echo "${ECHO_T}yes" >&6
4714 else
4715   echo "$as_me: failed program was:" >&5
4716 sed 's/^/| /' conftest.$ac_ext >&5
4717
4718 echo "$as_me:$LINENO: result: no" >&5
4719 echo "${ECHO_T}no" >&6; have_gmp=no
4720 fi
4721 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4722
4723   # If we have GMP, check the MPFR version.
4724   if test x"$have_gmp" = xyes; then
4725         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4726 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4727     cat >conftest.$ac_ext <<_ACEOF
4728 /* confdefs.h.  */
4729 _ACEOF
4730 cat confdefs.h >>conftest.$ac_ext
4731 cat >>conftest.$ac_ext <<_ACEOF
4732 /* end confdefs.h.  */
4733 #include <gmp.h>
4734     #include <mpfr.h>
4735 int
4736 main ()
4737 {
4738
4739     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4740     choke me
4741     #endif
4742
4743   ;
4744   return 0;
4745 }
4746 _ACEOF
4747 rm -f conftest.$ac_objext
4748 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4749   (eval $ac_compile) 2>conftest.er1
4750   ac_status=$?
4751   grep -v '^ *+' conftest.er1 >conftest.err
4752   rm -f conftest.er1
4753   cat conftest.err >&5
4754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4755   (exit $ac_status); } &&
4756          { ac_try='test -z "$ac_c_werror_flag"
4757                          || test ! -s conftest.err'
4758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4759   (eval $ac_try) 2>&5
4760   ac_status=$?
4761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4762   (exit $ac_status); }; } &&
4763          { ac_try='test -s conftest.$ac_objext'
4764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4765   (eval $ac_try) 2>&5
4766   ac_status=$?
4767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4768   (exit $ac_status); }; }; then
4769   cat >conftest.$ac_ext <<_ACEOF
4770 /* confdefs.h.  */
4771 _ACEOF
4772 cat confdefs.h >>conftest.$ac_ext
4773 cat >>conftest.$ac_ext <<_ACEOF
4774 /* end confdefs.h.  */
4775 #include <gmp.h>
4776     #include <mpfr.h>
4777 int
4778 main ()
4779 {
4780
4781     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4782     choke me
4783     #endif
4784
4785   ;
4786   return 0;
4787 }
4788 _ACEOF
4789 rm -f conftest.$ac_objext
4790 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4791   (eval $ac_compile) 2>conftest.er1
4792   ac_status=$?
4793   grep -v '^ *+' conftest.er1 >conftest.err
4794   rm -f conftest.er1
4795   cat conftest.err >&5
4796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4797   (exit $ac_status); } &&
4798          { ac_try='test -z "$ac_c_werror_flag"
4799                          || test ! -s conftest.err'
4800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4801   (eval $ac_try) 2>&5
4802   ac_status=$?
4803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4804   (exit $ac_status); }; } &&
4805          { ac_try='test -s conftest.$ac_objext'
4806   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4807   (eval $ac_try) 2>&5
4808   ac_status=$?
4809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4810   (exit $ac_status); }; }; then
4811   echo "$as_me:$LINENO: result: yes" >&5
4812 echo "${ECHO_T}yes" >&6
4813 else
4814   echo "$as_me: failed program was:" >&5
4815 sed 's/^/| /' conftest.$ac_ext >&5
4816
4817 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4818 echo "${ECHO_T}buggy but acceptable" >&6
4819 fi
4820 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4821 else
4822   echo "$as_me: failed program was:" >&5
4823 sed 's/^/| /' conftest.$ac_ext >&5
4824
4825 echo "$as_me:$LINENO: result: no" >&5
4826 echo "${ECHO_T}no" >&6; have_gmp=no
4827 fi
4828 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4829   fi
4830
4831   # Check for the MPC header version.
4832   if test x"$have_mpc" != xyes ; then
4833     CFLAGS="$CFLAGS $mpcinc"
4834     echo "$as_me:$LINENO: checking for the correct version of mpc.h" >&5
4835 echo $ECHO_N "checking for the correct version of mpc.h... $ECHO_C" >&6
4836     cat >conftest.$ac_ext <<_ACEOF
4837 /* confdefs.h.  */
4838 _ACEOF
4839 cat confdefs.h >>conftest.$ac_ext
4840 cat >>conftest.$ac_ext <<_ACEOF
4841 /* end confdefs.h.  */
4842 #include <mpc.h>
4843 int
4844 main ()
4845 {
4846
4847     #if MPC_VERSION < MPC_VERSION_NUM (0,6,0)
4848     choke me
4849     #endif
4850
4851   ;
4852   return 0;
4853 }
4854 _ACEOF
4855 rm -f conftest.$ac_objext
4856 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4857   (eval $ac_compile) 2>conftest.er1
4858   ac_status=$?
4859   grep -v '^ *+' conftest.er1 >conftest.err
4860   rm -f conftest.er1
4861   cat conftest.err >&5
4862   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4863   (exit $ac_status); } &&
4864          { ac_try='test -z "$ac_c_werror_flag"
4865                          || test ! -s conftest.err'
4866   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4867   (eval $ac_try) 2>&5
4868   ac_status=$?
4869   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4870   (exit $ac_status); }; } &&
4871          { ac_try='test -s conftest.$ac_objext'
4872   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4873   (eval $ac_try) 2>&5
4874   ac_status=$?
4875   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4876   (exit $ac_status); }; }; then
4877   echo "$as_me:$LINENO: result: yes" >&5
4878 echo "${ECHO_T}yes" >&6; have_mpc=maybe
4879 else
4880   echo "$as_me: failed program was:" >&5
4881 sed 's/^/| /' conftest.$ac_ext >&5
4882
4883 echo "$as_me:$LINENO: result: no" >&5
4884 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
4885 fi
4886 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4887   fi
4888
4889   # Now check the MPFR library.
4890   if test x"$have_gmp" = xyes; then
4891     saved_LIBS="$LIBS"
4892     LIBS="$LIBS $gmplibs"
4893     echo "$as_me:$LINENO: checking for the correct version of the gmp/mpfr libraries" >&5
4894 echo $ECHO_N "checking for the correct version of the gmp/mpfr libraries... $ECHO_C" >&6
4895     cat >conftest.$ac_ext <<_ACEOF
4896 /* confdefs.h.  */
4897 _ACEOF
4898 cat confdefs.h >>conftest.$ac_ext
4899 cat >>conftest.$ac_ext <<_ACEOF
4900 /* end confdefs.h.  */
4901 #include <gmp.h>
4902     #include <mpfr.h>
4903 int
4904 main ()
4905 {
4906
4907     mpfr_t n;
4908     mpfr_t x;
4909     int t;
4910     mpfr_init (n);
4911     mpfr_init (x);
4912     mpfr_atan2 (n, n, x, GMP_RNDN);
4913     mpfr_erfc (n, x, GMP_RNDN);
4914     mpfr_subnormalize (x, t, GMP_RNDN);
4915
4916   ;
4917   return 0;
4918 }
4919 _ACEOF
4920 rm -f conftest.$ac_objext conftest$ac_exeext
4921 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4922   (eval $ac_link) 2>conftest.er1
4923   ac_status=$?
4924   grep -v '^ *+' conftest.er1 >conftest.err
4925   rm -f conftest.er1
4926   cat conftest.err >&5
4927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4928   (exit $ac_status); } &&
4929          { ac_try='test -z "$ac_c_werror_flag"
4930                          || test ! -s conftest.err'
4931   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4932   (eval $ac_try) 2>&5
4933   ac_status=$?
4934   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4935   (exit $ac_status); }; } &&
4936          { ac_try='test -s conftest$ac_exeext'
4937   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4938   (eval $ac_try) 2>&5
4939   ac_status=$?
4940   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4941   (exit $ac_status); }; }; then
4942   echo "$as_me:$LINENO: result: yes" >&5
4943 echo "${ECHO_T}yes" >&6
4944 else
4945   echo "$as_me: failed program was:" >&5
4946 sed 's/^/| /' conftest.$ac_ext >&5
4947
4948 echo "$as_me:$LINENO: result: no" >&5
4949 echo "${ECHO_T}no" >&6; have_gmp=no
4950 fi
4951 rm -f conftest.err conftest.$ac_objext \
4952       conftest$ac_exeext conftest.$ac_ext
4953     LIBS="$saved_LIBS"
4954   fi
4955
4956   if test x"$have_mpc" = xmaybe; then
4957     saved_LIBS="$LIBS"
4958     LIBS="$LIBS $mpclibs $gmplibs"
4959     echo "$as_me:$LINENO: checking for the correct version of the mpc library" >&5
4960 echo $ECHO_N "checking for the correct version of the mpc library... $ECHO_C" >&6
4961     cat >conftest.$ac_ext <<_ACEOF
4962 /* confdefs.h.  */
4963 _ACEOF
4964 cat confdefs.h >>conftest.$ac_ext
4965 cat >>conftest.$ac_ext <<_ACEOF
4966 /* end confdefs.h.  */
4967 #include <mpc.h>
4968 int
4969 main ()
4970 {
4971
4972     mpc_t n;
4973     mpc_init2 (n, 53);
4974     mpc_set_ui_ui (n, 1, 1, MPC_RNDNN);
4975     mpc_sin (n, n, MPC_RNDNN);
4976     mpc_cos (n, n, MPC_RNDNN);
4977     mpc_tan (n, n, MPC_RNDNN);
4978     mpc_sinh (n, n, MPC_RNDNN);
4979     mpc_cosh (n, n, MPC_RNDNN);
4980     mpc_tanh (n, n, MPC_RNDNN);
4981     mpc_exp (n, n, MPC_RNDNN);
4982     mpc_log (n, n, MPC_RNDNN);
4983     mpc_sqrt (n, n, MPC_RNDNN);
4984     mpc_proj (n, n, MPC_RNDNN);
4985     mpc_neg (n, n, MPC_RNDNN);
4986     mpc_sqr (n, n, MPC_RNDNN);
4987     mpc_clear (n);
4988
4989   ;
4990   return 0;
4991 }
4992 _ACEOF
4993 rm -f conftest.$ac_objext conftest$ac_exeext
4994 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4995   (eval $ac_link) 2>conftest.er1
4996   ac_status=$?
4997   grep -v '^ *+' conftest.er1 >conftest.err
4998   rm -f conftest.er1
4999   cat conftest.err >&5
5000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5001   (exit $ac_status); } &&
5002          { ac_try='test -z "$ac_c_werror_flag"
5003                          || test ! -s conftest.err'
5004   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5005   (eval $ac_try) 2>&5
5006   ac_status=$?
5007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5008   (exit $ac_status); }; } &&
5009          { ac_try='test -s conftest$ac_exeext'
5010   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5011   (eval $ac_try) 2>&5
5012   ac_status=$?
5013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5014   (exit $ac_status); }; }; then
5015   echo "$as_me:$LINENO: result: yes" >&5
5016 echo "${ECHO_T}yes" >&6; have_mpc=yes
5017 else
5018   echo "$as_me: failed program was:" >&5
5019 sed 's/^/| /' conftest.$ac_ext >&5
5020
5021 echo "$as_me:$LINENO: result: no" >&5
5022 echo "${ECHO_T}no" >&6; have_mpc=no; mpclibs= ; mpcinc=
5023 fi
5024 rm -f conftest.err conftest.$ac_objext \
5025       conftest$ac_exeext conftest.$ac_ext
5026     LIBS="$saved_LIBS"
5027   fi
5028
5029   CFLAGS="$saved_CFLAGS"
5030
5031   if test x$have_gmp != xyes; then
5032     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5033 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5034 Copies of these libraries' source code can be found at their respective
5035 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5036 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5037 If you obtained GMP and/or MPFR from a vendor distribution package, make
5038 sure that you have installed both the libraries and the header files.
5039 They may be located in separate packages." >&5
5040 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
5041 Try the --with-gmp and/or --with-mpfr options to specify their locations.
5042 Copies of these libraries' source code can be found at their respective
5043 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
5044 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
5045 If you obtained GMP and/or MPFR from a vendor distribution package, make
5046 sure that you have installed both the libraries and the header files.
5047 They may be located in separate packages." >&2;}
5048    { (exit 1); exit 1; }; }
5049   fi
5050 fi
5051
5052 gmpinc="$mpcinc $gmpinc"
5053 gmplibs="$mpclibs $gmplibs"
5054
5055 # Flags needed for both GMP, MPFR and/or MPC.
5056
5057
5058
5059
5060
5061
5062 # Allow host libstdc++ to be specified for static linking with PPL.
5063
5064 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
5065 if test "${with_host_libstdcxx+set}" = set; then
5066   withval="$with_host_libstdcxx"
5067
5068 fi;
5069
5070 case $with_host_libstdcxx in
5071   no|yes)
5072     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
5073 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
5074    { (exit 1); exit 1; }; }
5075     ;;
5076 esac
5077
5078 # Check for PPL
5079 ppl_major_version=0
5080 ppl_minor_version=10
5081 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
5082 pplinc=
5083
5084
5085 # Check whether --with-ppl or --without-ppl was given.
5086 if test "${with_ppl+set}" = set; then
5087   withval="$with_ppl"
5088
5089 else
5090   with_ppl=no
5091 fi;
5092
5093 # Check whether --with-ppl_include or --without-ppl_include was given.
5094 if test "${with_ppl_include+set}" = set; then
5095   withval="$with_ppl_include"
5096
5097 fi;
5098
5099 # Check whether --with-ppl_lib or --without-ppl_lib was given.
5100 if test "${with_ppl_lib+set}" = set; then
5101   withval="$with_ppl_lib"
5102
5103 fi;
5104
5105 case $with_ppl in
5106   no)
5107     ppllibs=
5108     ;;
5109   *)
5110     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
5111     pplinc="-I$with_ppl/include $pplinc"
5112     LIBS="$ppllibs $LIBS"
5113     ;;
5114 esac
5115 if test "x$with_ppl_include" != x; then
5116   pplinc="-I$with_ppl_include $pplinc"
5117 fi
5118 if test "x$with_ppl_lib" != x; then
5119   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
5120   LIBS="$ppllibs $LIBS"
5121 fi
5122 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
5123   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
5124   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
5125   LIBS="$ppllibs $LIBS"
5126 fi
5127
5128 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
5129 if test "${enable_ppl_version_check+set}" = set; then
5130   enableval="$enable_ppl_version_check"
5131   ENABLE_PPL_CHECK=$enableval
5132 else
5133   ENABLE_PPL_CHECK=yes
5134 fi;
5135
5136 if test "${ENABLE_PPL_CHECK}" = "yes"; then
5137   saved_CFLAGS="$CFLAGS"
5138   CFLAGS="$CFLAGS $pplinc $gmpinc"
5139   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
5140 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
5141   cat >conftest.$ac_ext <<_ACEOF
5142 /* confdefs.h.  */
5143 _ACEOF
5144 cat confdefs.h >>conftest.$ac_ext
5145 cat >>conftest.$ac_ext <<_ACEOF
5146 /* end confdefs.h.  */
5147 #include "ppl_c.h"
5148 int
5149 main ()
5150 {
5151
5152   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
5153   choke me
5154   #endif
5155
5156   ;
5157   return 0;
5158 }
5159 _ACEOF
5160 rm -f conftest.$ac_objext
5161 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5162   (eval $ac_compile) 2>conftest.er1
5163   ac_status=$?
5164   grep -v '^ *+' conftest.er1 >conftest.err
5165   rm -f conftest.er1
5166   cat conftest.err >&5
5167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5168   (exit $ac_status); } &&
5169          { ac_try='test -z "$ac_c_werror_flag"
5170                          || test ! -s conftest.err'
5171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5172   (eval $ac_try) 2>&5
5173   ac_status=$?
5174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5175   (exit $ac_status); }; } &&
5176          { ac_try='test -s conftest.$ac_objext'
5177   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5178   (eval $ac_try) 2>&5
5179   ac_status=$?
5180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5181   (exit $ac_status); }; }; then
5182   echo "$as_me:$LINENO: result: yes" >&5
5183 echo "${ECHO_T}yes" >&6
5184 else
5185   echo "$as_me: failed program was:" >&5
5186 sed 's/^/| /' conftest.$ac_ext >&5
5187
5188 echo "$as_me:$LINENO: result: no" >&5
5189 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
5190 fi
5191 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5192   CFLAGS="$saved_CFLAGS"
5193 fi
5194
5195 # Flags needed for PPL
5196
5197
5198
5199
5200 # Check for CLOOG
5201 clooglibs=" -lcloog "
5202 clooginc=" -DCLOOG_PPL_BACKEND "
5203
5204
5205 # Check whether --with-cloog or --without-cloog was given.
5206 if test "${with_cloog+set}" = set; then
5207   withval="$with_cloog"
5208
5209 else
5210   with_cloog=no
5211 fi;
5212
5213 # Check whether --with-cloog_include or --without-cloog_include was given.
5214 if test "${with_cloog_include+set}" = set; then
5215   withval="$with_cloog_include"
5216
5217 fi;
5218
5219 # Check whether --with-cloog_lib or --without-cloog_lib was given.
5220 if test "${with_cloog_lib+set}" = set; then
5221   withval="$with_cloog_lib"
5222
5223 fi;
5224
5225 case $with_cloog in
5226   no)
5227     clooglibs=
5228     clooginc=
5229     ;;
5230   *)
5231     clooglibs="-L$with_cloog/lib -lcloog"
5232     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
5233     LIBS="$clooglibs $LIBS"
5234     ;;
5235 esac
5236 if test "x$with_cloog_include" != x; then
5237   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
5238 fi
5239 if test "x$with_cloog_lib" != x; then
5240   clooglibs="-L$with_cloog_lib -lcloog"
5241   LIBS="$clooglibs $LIBS"
5242 fi
5243 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
5244   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
5245   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
5246   LIBS="$clooglibs $LIBS"
5247 fi
5248
5249 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5250 if test "${enable_cloog_version_check+set}" = set; then
5251   enableval="$enable_cloog_version_check"
5252   ENABLE_CLOOG_CHECK=$enableval
5253 else
5254   ENABLE_CLOOG_CHECK=yes
5255 fi;
5256
5257 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5258   saved_CFLAGS="$CFLAGS"
5259   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5260   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5261 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5262   cat >conftest.$ac_ext <<_ACEOF
5263 /* confdefs.h.  */
5264 _ACEOF
5265 cat confdefs.h >>conftest.$ac_ext
5266 cat >>conftest.$ac_ext <<_ACEOF
5267 /* end confdefs.h.  */
5268 #include "cloog/cloog.h"
5269 int
5270 main ()
5271 {
5272
5273   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5274   choke me
5275   #endif
5276
5277   ;
5278   return 0;
5279 }
5280 _ACEOF
5281 rm -f conftest.$ac_objext
5282 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5283   (eval $ac_compile) 2>conftest.er1
5284   ac_status=$?
5285   grep -v '^ *+' conftest.er1 >conftest.err
5286   rm -f conftest.er1
5287   cat conftest.err >&5
5288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5289   (exit $ac_status); } &&
5290          { ac_try='test -z "$ac_c_werror_flag"
5291                          || test ! -s conftest.err'
5292   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5293   (eval $ac_try) 2>&5
5294   ac_status=$?
5295   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5296   (exit $ac_status); }; } &&
5297          { ac_try='test -s conftest.$ac_objext'
5298   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5299   (eval $ac_try) 2>&5
5300   ac_status=$?
5301   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5302   (exit $ac_status); }; }; then
5303   echo "$as_me:$LINENO: result: yes" >&5
5304 echo "${ECHO_T}yes" >&6
5305 else
5306   echo "$as_me: failed program was:" >&5
5307 sed 's/^/| /' conftest.$ac_ext >&5
5308
5309 echo "$as_me:$LINENO: result: no" >&5
5310 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5311 fi
5312 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5313   CFLAGS="$saved_CFLAGS"
5314 fi
5315
5316 # Flags needed for CLOOG
5317
5318
5319
5320
5321 # By default, C is the only stage 1 language.
5322 stage1_languages=,c,
5323
5324 # Figure out what language subdirectories are present.
5325 # Look if the user specified --enable-languages="..."; if not, use
5326 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5327 # go away some day.
5328 # NB:  embedded tabs in this IF block -- do not untabify
5329 if test -d ${srcdir}/gcc; then
5330   if test x"${enable_languages+set}" != xset; then
5331     if test x"${LANGUAGES+set}" = xset; then
5332       enable_languages="${LANGUAGES}"
5333         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5334     else
5335       enable_languages=all
5336     fi
5337   else
5338     if test x"${enable_languages}" = x ||
5339        test x"${enable_languages}" = xyes;
5340        then
5341       echo configure.in: --enable-languages needs at least one language argument 1>&2
5342       exit 1
5343     fi
5344   fi
5345   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5346
5347   # 'f95' is the old name for the 'fortran' language. We issue a warning
5348   # and make the substitution.
5349   case ,${enable_languages}, in
5350     *,f95,*)
5351       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5352       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5353       ;;
5354   esac
5355
5356   # First scan to see if an enabled language requires some other language.
5357   # We assume that a given config-lang.in will list all the language
5358   # front ends it requires, even if some are required indirectly.
5359   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5360     case ${lang_frag} in
5361       ..) ;;
5362       # The odd quoting in the next line works around
5363       # an apparent bug in bash 1.12 on linux.
5364       ${srcdir}/gcc/[*]/config-lang.in) ;;
5365       *)
5366         # From the config-lang.in, get $language, $lang_requires
5367         language=
5368         lang_requires=
5369         . ${lang_frag}
5370         for other in ${lang_requires} ; do
5371           case ,${enable_languages}, in
5372             *,$other,*) ;;
5373             *,all,*) ;;
5374             *,$language,*)
5375               echo " \`$other' language required by \`$language'; enabling" 1>&2
5376               enable_languages="${enable_languages},${other}"
5377               ;;
5378           esac
5379         done
5380         ;;
5381     esac
5382   done
5383
5384   new_enable_languages=,c,
5385   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5386   potential_languages=,c,
5387
5388   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5389     case ${lang_frag} in
5390       ..) ;;
5391       # The odd quoting in the next line works around
5392       # an apparent bug in bash 1.12 on linux.
5393       ${srcdir}/gcc/[*]/config-lang.in) ;;
5394       *)
5395         # From the config-lang.in, get $language, $target_libs,
5396         # $lang_dirs, $boot_language, and $build_by_default
5397         language=
5398         target_libs=
5399         lang_dirs=
5400         subdir_requires=
5401         boot_language=no
5402         build_by_default=yes
5403         . ${lang_frag}
5404         if test x${language} = x; then
5405           echo "${lang_frag} doesn't set \$language." 1>&2
5406           exit 1
5407         fi
5408
5409         case ,${enable_languages}, in
5410           *,${language},*)
5411             # Language was explicitly selected; include it.
5412             add_this_lang=yes
5413             ;;
5414           *,all,*)
5415             # 'all' was selected, select it if it is a default language
5416             add_this_lang=${build_by_default}
5417             ;;
5418           *)
5419             add_this_lang=no
5420             ;;
5421         esac
5422
5423         # Disable languages that need other directories if these aren't available.
5424         for i in $subdir_requires; do
5425           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5426           case ,${enable_languages}, in
5427             *,${language},*)
5428               # Specifically requested language; tell them.
5429               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5430 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5431    { (exit 1); exit 1; }; }
5432               ;;
5433             *)
5434               # Silently disable.
5435               add_this_lang=unsupported
5436               ;;
5437           esac
5438         done
5439
5440         # Disable Ada if no preexisting GNAT is available.
5441         case ,${enable_languages},:${language}:${have_gnat} in
5442           *,${language},*:ada:no)
5443             # Specifically requested language; tell them.
5444             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5445 echo "$as_me: error: GNAT is required to build $language" >&2;}
5446    { (exit 1); exit 1; }; }
5447             ;;
5448           *:ada:no)
5449             # Silently disable.
5450             add_this_lang=unsupported
5451             ;;
5452         esac
5453
5454         # Disable a language that is unsupported by the target.
5455         case " $unsupported_languages " in
5456           *" $language "*)
5457             add_this_lang=unsupported
5458             ;;
5459         esac
5460
5461         case $add_this_lang in
5462           unsupported)
5463             # Remove language-dependent dirs.
5464             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5465             ;;
5466           no)
5467             # Remove language-dependent dirs; still show language as supported.
5468             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5469             potential_languages="${potential_languages}${language},"
5470             ;;
5471           yes)
5472             new_enable_languages="${new_enable_languages}${language},"
5473             potential_languages="${potential_languages}${language},"
5474             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5475             case ${boot_language} in
5476               yes)
5477                 # Add to (comma-separated) list of stage 1 languages.
5478                 stage1_languages="${stage1_languages}${language},"
5479                 ;;
5480             esac
5481             ;;
5482         esac
5483         ;;
5484     esac
5485   done
5486
5487   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5488 if test "${enable_stage1_languages+set}" = set; then
5489   enableval="$enable_stage1_languages"
5490   case ,${enable_stage1_languages}, in
5491     ,no,|,,)
5492       # Set it to something that will have no effect in the loop below
5493       enable_stage1_languages=c ;;
5494     ,yes,)
5495       enable_stage1_languages=`echo $new_enable_languages | \
5496         sed -e "s/^,//" -e "s/,$//" ` ;;
5497     *,all,*)
5498       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5499         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5500   esac
5501
5502   # Add "good" languages from enable_stage1_languages to stage1_languages,
5503   # while "bad" languages go in missing_languages.  Leave no duplicates.
5504   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5505     case $potential_languages in
5506       *,$i,*)
5507         case $stage1_languages in
5508           *,$i,*) ;;
5509           *) stage1_languages="$stage1_languages$i," ;;
5510         esac ;;
5511       *)
5512         case $missing_languages in
5513           *,$i,*) ;;
5514           *) missing_languages="$missing_languages$i," ;;
5515         esac ;;
5516      esac
5517   done
5518 fi;
5519
5520   # Remove leading/trailing commas that were added for simplicity
5521   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5522   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5523   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5524   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5525
5526   if test "x$missing_languages" != x; then
5527     { { echo "$as_me:$LINENO: error:
5528 The following requested languages could not be built: ${missing_languages}
5529 Supported languages are: ${potential_languages}" >&5
5530 echo "$as_me: error:
5531 The following requested languages could not be built: ${missing_languages}
5532 Supported languages are: ${potential_languages}" >&2;}
5533    { (exit 1); exit 1; }; }
5534   fi
5535   if test "x$new_enable_languages" != "x$enable_languages"; then
5536     echo The following languages will be built: ${new_enable_languages}
5537     enable_languages="$new_enable_languages"
5538   fi
5539
5540
5541   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5542 fi
5543
5544 # Handle --disable-<component> generically.
5545 for dir in $configdirs $build_configdirs $target_configdirs ; do
5546   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5547   varname=`echo $dirname | sed -e s/+/_/g`
5548   if eval test x\${enable_${varname}} "=" xno ; then
5549     noconfigdirs="$noconfigdirs $dir"
5550   fi
5551 done
5552
5553 # Check for Boehm's garbage collector
5554 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5555 if test "${enable_objc_gc+set}" = set; then
5556   enableval="$enable_objc_gc"
5557   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5558   *,objc,*:*:yes:*target-boehm-gc*)
5559     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5560 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5561    { (exit 1); exit 1; }; }
5562     ;;
5563 esac
5564 fi;
5565
5566 # Make sure we only build Boehm's garbage collector if required.
5567 case ,${enable_languages},:${enable_objc_gc} in
5568   *,objc,*:yes)
5569     # Keep target-boehm-gc if requested for Objective-C.
5570     ;;
5571   *)
5572     # Otherwise remove target-boehm-gc depending on target-libjava.
5573     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5574       noconfigdirs="$noconfigdirs target-boehm-gc"
5575     fi
5576     ;;
5577 esac
5578
5579 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5580 # $build_configdirs and $target_configdirs.
5581 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5582
5583 notsupp=""
5584 for dir in . $skipdirs $noconfigdirs ; do
5585   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5586   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5587     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5588     if test -r $srcdir/$dirname/configure ; then
5589       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5590         true
5591       else
5592         notsupp="$notsupp $dir"
5593       fi
5594     fi
5595   fi
5596   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5597     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5598     if test -r $srcdir/$dirname/configure ; then
5599       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5600         true
5601       else
5602         notsupp="$notsupp $dir"
5603       fi
5604     fi
5605   fi
5606   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5607     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5608     if test -r $srcdir/$dirname/configure ; then
5609       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5610         true
5611       else
5612         notsupp="$notsupp $dir"
5613       fi
5614     fi
5615   fi
5616 done
5617
5618 # Sometimes the tools are distributed with libiberty but with no other
5619 # libraries.  In that case, we don't want to build target-libiberty.
5620 # Don't let libgcc imply libiberty either.
5621 if test -n "${target_configdirs}" ; then
5622   libgcc=
5623   others=
5624   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5625     if test "$i" = "libgcc"; then
5626       libgcc=target-libgcc
5627     elif test "$i" != "libiberty" ; then
5628       if test -r $srcdir/$i/configure ; then
5629         others=yes;
5630         break;
5631       fi
5632     fi
5633   done
5634   if test -z "${others}" ; then
5635     target_configdirs=$libgcc
5636   fi
5637 fi
5638
5639 # Quietly strip out all directories which aren't configurable in this tree.
5640 # This relies on all configurable subdirectories being autoconfiscated, which
5641 # is now the case.
5642 build_configdirs_all="$build_configdirs"
5643 build_configdirs=
5644 for i in ${build_configdirs_all} ; do
5645   j=`echo $i | sed -e s/build-//g`
5646   if test -f ${srcdir}/$j/configure ; then
5647     build_configdirs="${build_configdirs} $i"
5648   fi
5649 done
5650
5651 configdirs_all="$configdirs"
5652 configdirs=
5653 for i in ${configdirs_all} ; do
5654   if test -f ${srcdir}/$i/configure ; then
5655     configdirs="${configdirs} $i"
5656   fi
5657 done
5658
5659 target_configdirs_all="$target_configdirs"
5660 target_configdirs=
5661 for i in ${target_configdirs_all} ; do
5662   j=`echo $i | sed -e s/target-//g`
5663   if test -f ${srcdir}/$j/configure ; then
5664     target_configdirs="${target_configdirs} $i"
5665   fi
5666 done
5667
5668 # Produce a warning message for the subdirs we can't configure.
5669 # This isn't especially interesting in the Cygnus tree, but in the individual
5670 # FSF releases, it's important to let people know when their machine isn't
5671 # supported by the one or two programs in a package.
5672
5673 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5674   # If $appdirs is non-empty, at least one of those directories must still
5675   # be configured, or we error out.  (E.g., if the gas release supports a
5676   # specified target in some subdirs but not the gas subdir, we shouldn't
5677   # pretend that all is well.)
5678   if test -n "$appdirs" ; then
5679     for dir in $appdirs ; do
5680       if test -r $dir/Makefile.in ; then
5681         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5682           appdirs=""
5683           break
5684         fi
5685         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5686           appdirs=""
5687           break
5688         fi
5689       fi
5690     done
5691     if test -n "$appdirs" ; then
5692       echo "*** This configuration is not supported by this package." 1>&2
5693       exit 1
5694     fi
5695   fi
5696   # Okay, some application will build, or we don't care to check.  Still
5697   # notify of subdirs not getting built.
5698   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5699   echo "    ${notsupp}" 1>&2
5700   echo "    (Any other directories should still work fine.)" 1>&2
5701 fi
5702
5703 case "$host" in
5704   *msdosdjgpp*)
5705     enable_gdbtk=no ;;
5706 esac
5707
5708 # To find our prefix, in gcc_cv_tool_prefix.
5709
5710 # The user is always right.
5711 if test "${PATH_SEPARATOR+set}" != set; then
5712   echo "#! /bin/sh" >conf$$.sh
5713   echo  "exit 0"   >>conf$$.sh
5714   chmod +x conf$$.sh
5715   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5716     PATH_SEPARATOR=';'
5717   else
5718     PATH_SEPARATOR=:
5719   fi
5720   rm -f conf$$.sh
5721 fi
5722
5723
5724
5725 if test "x$exec_prefix" = xNONE; then
5726         if test "x$prefix" = xNONE; then
5727                 gcc_cv_tool_prefix=$ac_default_prefix
5728         else
5729                 gcc_cv_tool_prefix=$prefix
5730         fi
5731 else
5732         gcc_cv_tool_prefix=$exec_prefix
5733 fi
5734
5735 # If there is no compiler in the tree, use the PATH only.  In any
5736 # case, if there is no compiler in the tree nobody should use
5737 # AS_FOR_TARGET and LD_FOR_TARGET.
5738 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5739     gcc_version=`cat $srcdir/gcc/BASE-VER`
5740     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5741     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5742     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5743     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5744     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5745     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5746 else
5747     gcc_cv_tool_dirs=
5748 fi
5749
5750 if test x$build = x$target && test -n "$md_exec_prefix"; then
5751         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5752 fi
5753
5754
5755
5756 copy_dirs=
5757
5758
5759 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5760 if test "${with_build_sysroot+set}" = set; then
5761   withval="$with_build_sysroot"
5762   if test x"$withval" != x ; then
5763      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5764    fi
5765 else
5766   SYSROOT_CFLAGS_FOR_TARGET=
5767 fi;
5768
5769
5770
5771 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5772 if test "${with_debug_prefix_map+set}" = set; then
5773   withval="$with_debug_prefix_map"
5774   if test x"$withval" != x; then
5775      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5776      for debug_map in $withval; do
5777        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5778      done
5779    fi
5780 else
5781   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5782 fi;
5783
5784
5785 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5786 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5787 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5788 # We want to ensure that TARGET libraries (which we know are built with
5789 # gcc) are built with "-O2 -g", so include those options when setting
5790 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5791 if test "x$CFLAGS_FOR_TARGET" = x; then
5792   CFLAGS_FOR_TARGET=$CFLAGS
5793   case " $CFLAGS " in
5794     *" -O2 "*) ;;
5795     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5796   esac
5797   case " $CFLAGS " in
5798     *" -g "* | *" -g3 "*) ;;
5799     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5800   esac
5801 fi
5802
5803
5804 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5805   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5806   case " $CXXFLAGS " in
5807     *" -O2 "*) ;;
5808     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5809   esac
5810   case " $CXXFLAGS " in
5811     *" -g "* | *" -g3 "*) ;;
5812     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5813   esac
5814 fi
5815
5816
5817 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5818 # the named directory are copied to $(tooldir)/sys-include.
5819 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5820   if test x${is_cross_compiler} = xno ; then
5821     echo 1>&2 '***' --with-headers is only supported when cross compiling
5822     exit 1
5823   fi
5824   if test x"${with_headers}" != xyes ; then
5825     x=${gcc_cv_tool_prefix}
5826     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5827   fi
5828 fi
5829
5830 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5831 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5832 # are permitted.
5833 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5834   if test x${is_cross_compiler} = xno ; then
5835     echo 1>&2 '***' --with-libs is only supported when cross compiling
5836     exit 1
5837   fi
5838   if test x"${with_libs}" != xyes ; then
5839     # Copy the libraries in reverse order, so that files in the first named
5840     # library override files in subsequent libraries.
5841     x=${gcc_cv_tool_prefix}
5842     for l in ${with_libs}; do
5843       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5844     done
5845   fi
5846 fi
5847
5848 # Set with_gnu_as and with_gnu_ld as appropriate.
5849 #
5850 # This is done by determining whether or not the appropriate directory
5851 # is available, and by checking whether or not specific configurations
5852 # have requested that this magic not happen.
5853 #
5854 # The command line options always override the explicit settings in
5855 # configure.in, and the settings in configure.in override this magic.
5856 #
5857 # If the default for a toolchain is to use GNU as and ld, and you don't
5858 # want to do that, then you should use the --without-gnu-as and
5859 # --without-gnu-ld options for the configure script.
5860
5861 if test x${use_gnu_as} = x &&
5862    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5863   with_gnu_as=yes
5864   extra_host_args="$extra_host_args --with-gnu-as"
5865 fi
5866
5867 if test x${use_gnu_ld} = x &&
5868    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5869   with_gnu_ld=yes
5870   extra_host_args="$extra_host_args --with-gnu-ld"
5871 fi
5872
5873 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5874 # can detect this case.
5875
5876 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5877   with_newlib=yes
5878   extra_host_args="$extra_host_args --with-newlib"
5879 fi
5880
5881 # Handle ${copy_dirs}
5882 set fnord ${copy_dirs}
5883 shift
5884 while test $# != 0 ; do
5885   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5886     :
5887   else
5888     echo Copying $1 to $2
5889
5890     # Use the install script to create the directory and all required
5891     # parent directories.
5892     if test -d $2 ; then
5893       :
5894     else
5895       echo >config.temp
5896       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5897     fi
5898
5899     # Copy the directory, assuming we have tar.
5900     # FIXME: Should we use B in the second tar?  Not all systems support it.
5901     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5902
5903     # It is the responsibility of the user to correctly adjust all
5904     # symlinks.  If somebody can figure out how to handle them correctly
5905     # here, feel free to add the code.
5906
5907     echo $1 > $2/COPIED
5908   fi
5909   shift; shift
5910 done
5911
5912 # Determine a target-dependent exec_prefix that the installed
5913 # gcc will search in.  Keep this list sorted by triplet, with
5914 # the *-*-osname triplets last.
5915 md_exec_prefix=
5916 case "${target}" in
5917   alpha*-*-*vms*)
5918     md_exec_prefix=/gnu/lib/gcc-lib
5919     ;;
5920   i[34567]86-pc-msdosdjgpp*)
5921     md_exec_prefix=/dev/env/DJDIR/bin
5922     ;;
5923   i[34567]86-*-sco3.2v5*)
5924     if test $with_gnu_as = yes; then
5925       md_exec_prefix=/usr/gnu/bin
5926     else
5927       md_exec_prefix=/usr/ccs/bin/elf
5928     fi
5929     ;;
5930
5931   mn10300-*-* | \
5932   powerpc-*-chorusos* | \
5933   powerpc*-*-eabi* | \
5934   powerpc*-*-sysv* | \
5935   powerpc*-*-kaos* | \
5936   s390x-ibm-tpf*)
5937     md_exec_prefix=/usr/ccs/bin
5938     ;;
5939   sparc64-*-elf*)
5940     ;;
5941   v850*-*-*)
5942     md_exec_prefix=/usr/ccs/bin
5943     ;;
5944   xtensa*-*-elf*)
5945     ;;
5946
5947   *-*-beos* | \
5948   *-*-elf* | \
5949   *-*-hpux* | \
5950   *-*-netware* | \
5951   *-*-nto-qnx* | \
5952   *-*-rtems* | \
5953   *-*-solaris2* | \
5954   *-*-sysv[45]* | \
5955   *-*-vxworks* | \
5956   *-wrs-windiss)
5957     md_exec_prefix=/usr/ccs/bin
5958     ;;
5959 esac
5960
5961 extra_arflags_for_target=
5962 extra_nmflags_for_target=
5963 extra_ranlibflags_for_target=
5964 target_makefile_frag=/dev/null
5965 case "${target}" in
5966   mep*-*-*)
5967     target_makefile_frag="config/mt-mep"
5968     ;;
5969   spu-*-*)
5970     target_makefile_frag="config/mt-spu"
5971     ;;
5972   mips*-sde-elf*)
5973     target_makefile_frag="config/mt-sde"
5974     ;;
5975   mipsisa*-*-elfoabi*)
5976     target_makefile_frag="config/mt-mips-elfoabi"
5977     ;;
5978   mips*-*-*linux* | mips*-*-gnu*)
5979     target_makefile_frag="config/mt-mips-gnu"
5980     ;;
5981   *-*-netware*)
5982     target_makefile_frag="config/mt-netware"
5983     ;;
5984   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5985     target_makefile_frag="config/mt-gnu"
5986     ;;
5987   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5988     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5989     # commands to handle both 32-bit and 64-bit objects.  These flags are
5990     # harmless if we're using GNU nm or ar.
5991     extra_arflags_for_target=" -X32_64"
5992     extra_nmflags_for_target=" -B -X32_64"
5993     ;;
5994   *-*-darwin*)
5995     # ranlib from Darwin requires the -c flag to look at common symbols.
5996     extra_ranlibflags_for_target=" -c"
5997     ;;
5998   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5999     target_makefile_frag="config/mt-wince"
6000     ;;
6001 esac
6002
6003 alphaieee_frag=/dev/null
6004 case $target in
6005   alpha*-*-*)
6006     # This just makes sure to use the -mieee option to build target libs.
6007     # This should probably be set individually by each library.
6008     alphaieee_frag="config/mt-alphaieee"
6009     ;;
6010 esac
6011
6012 # If --enable-target-optspace always use -Os instead of -O2 to build
6013 # the target libraries, similarly if it is not specified, use -Os
6014 # on selected platforms.
6015 ospace_frag=/dev/null
6016 case "${enable_target_optspace}:${target}" in
6017   yes:*)
6018     ospace_frag="config/mt-ospace"
6019     ;;
6020   :d30v-*)
6021     ospace_frag="config/mt-d30v"
6022     ;;
6023   :m32r-* | :d10v-* | :fr30-*)
6024     ospace_frag="config/mt-ospace"
6025     ;;
6026   no:* | :*)
6027     ;;
6028   *)
6029     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
6030     ;;
6031 esac
6032
6033 # Default to using --with-stabs for certain targets.
6034 if test x${with_stabs} = x ; then
6035   case "${target}" in
6036   mips*-*-irix[56]*)
6037     ;;
6038   mips*-*-* | alpha*-*-osf*)
6039     with_stabs=yes;
6040     extra_host_args="${extra_host_args} --with-stabs"
6041     ;;
6042   esac
6043 fi
6044
6045 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
6046 # them automatically.
6047 case "${host}" in
6048   hppa*64*-*-hpux11*)
6049     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
6050     ;;
6051 esac
6052
6053 # Some systems (e.g., one of the i386-aix systems the gas testers are
6054 # using) don't handle "\$" correctly, so don't use it here.
6055 tooldir='${exec_prefix}'/${target_noncanonical}
6056 build_tooldir=${tooldir}
6057
6058 # Create a .gdbinit file which runs the one in srcdir
6059 # and tells GDB to look there for source files.
6060
6061 if test -r ${srcdir}/.gdbinit ; then
6062   case ${srcdir} in
6063     .) ;;
6064     *) cat > ./.gdbinit <<EOF
6065 # ${NO_EDIT}
6066 dir ${srcdir}
6067 dir .
6068 source ${srcdir}/.gdbinit
6069 EOF
6070     ;;
6071   esac
6072 fi
6073
6074 # Make sure that the compiler is able to generate an executable.  If it
6075 # can't, we are probably in trouble.  We don't care whether we can run the
6076 # executable--we might be using a cross compiler--we only care whether it
6077 # can be created.  At this point the main configure script has set CC.
6078 we_are_ok=no
6079 echo "int main () { return 0; }" > conftest.c
6080 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
6081 if test $? = 0 ; then
6082   if test -s conftest || test -s conftest.exe ; then
6083     we_are_ok=yes
6084   fi
6085 fi
6086 case $we_are_ok in
6087   no)
6088     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
6089     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
6090     rm -f conftest*
6091     exit 1
6092     ;;
6093 esac
6094 rm -f conftest*
6095
6096 # The Solaris /usr/ucb/cc compiler does not appear to work.
6097 case "${host}" in
6098   sparc-sun-solaris2*)
6099       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
6100       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
6101           could_use=
6102           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
6103           if test -d /opt/cygnus/bin ; then
6104               if test "$could_use" = "" ; then
6105                   could_use="/opt/cygnus/bin"
6106               else
6107                   could_use="$could_use or /opt/cygnus/bin"
6108               fi
6109           fi
6110         if test "$could_use" = "" ; then
6111             echo "Warning: compilation may fail because you're using"
6112             echo "/usr/ucb/cc.  You should change your PATH or CC "
6113             echo "variable and rerun configure."
6114         else
6115             echo "Warning: compilation may fail because you're using"
6116             echo "/usr/ucb/cc, when you should use the C compiler from"
6117             echo "$could_use.  You should change your"
6118             echo "PATH or CC variable and rerun configure."
6119         fi
6120       fi
6121   ;;
6122 esac
6123
6124 # Decide which environment variable is used to find dynamic libraries.
6125 case "${host}" in
6126   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
6127   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
6128   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
6129   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
6130 esac
6131
6132 # On systems where the dynamic library environment variable is PATH,
6133 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
6134 # built executables to PATH.
6135 if test "$RPATH_ENVVAR" = PATH; then
6136   GCC_SHLIB_SUBDIR=/shlib
6137 else
6138   GCC_SHLIB_SUBDIR=
6139 fi
6140
6141 # Record target_configdirs and the configure arguments for target and
6142 # build configuration in Makefile.
6143 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
6144 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
6145
6146 # Determine whether gdb needs tk/tcl or not.
6147 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
6148 # and in that case we want gdb to be built without tk.  Ugh!
6149 # In fact I believe gdb is the *only* package directly dependent on tk,
6150 # so we should be able to put the 'maybe's in unconditionally and
6151 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
6152 # 100% sure that that's safe though.
6153
6154 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
6155 case "$enable_gdbtk" in
6156   no)
6157     GDB_TK="" ;;
6158   yes)
6159     GDB_TK="${gdb_tk}" ;;
6160   *)
6161     # Only add the dependency on gdbtk when GDBtk is part of the gdb
6162     # distro.  Eventually someone will fix this and move Insight, nee
6163     # gdbtk to a separate directory.
6164     if test -d ${srcdir}/gdb/gdbtk ; then
6165       GDB_TK="${gdb_tk}"
6166     else
6167       GDB_TK=""
6168     fi
6169     ;;
6170 esac
6171 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
6172 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
6173
6174 # Strip out unwanted targets.
6175
6176 # While at that, we remove Makefiles if we were started for recursive
6177 # configuration, so that the top-level Makefile reconfigures them,
6178 # like we used to do when configure itself was recursive.
6179
6180 # Loop over modules.  $extrasub must be used with care, limiting as
6181 # much as possible the usage of range addresses.  That's because autoconf
6182 # splits the sed script to overcome limits in the number of commands,
6183 # and relying on carefully-timed sed passes may turn out to be very hard
6184 # to maintain later.  In this particular case, you just have to be careful
6185 # not to nest @if/@endif pairs, because configure will not warn you at all.
6186
6187 # Check whether --enable-bootstrap or --disable-bootstrap was given.
6188 if test "${enable_bootstrap+set}" = set; then
6189   enableval="$enable_bootstrap"
6190
6191 else
6192   enable_bootstrap=default
6193 fi;
6194
6195 # Issue errors and warnings for invalid/strange bootstrap combinations.
6196 case "$configdirs" in
6197   *gcc*) have_compiler=yes ;;
6198   *) have_compiler=no ;;
6199 esac
6200
6201 case "$have_compiler:$host:$target:$enable_bootstrap" in
6202   *:*:*:no) ;;
6203
6204   # Default behavior.  Enable bootstrap if we have a compiler
6205   # and we are in a native configuration.
6206   yes:$build:$build:default)
6207     enable_bootstrap=yes ;;
6208
6209   *:*:*:default)
6210     enable_bootstrap=no ;;
6211
6212   # We have a compiler and we are in a native configuration, bootstrap is ok
6213   yes:$build:$build:yes)
6214     ;;
6215
6216   # Other configurations, but we have a compiler.  Assume the user knows
6217   # what he's doing.
6218   yes:*:*:yes)
6219     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
6220 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
6221     ;;
6222
6223   # No compiler: if they passed --enable-bootstrap explicitly, fail
6224   no:*:*:yes)
6225     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
6226 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
6227    { (exit 1); exit 1; }; } ;;
6228
6229   # Fail if wrong command line
6230   *)
6231     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
6232 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
6233    { (exit 1); exit 1; }; }
6234     ;;
6235 esac
6236
6237 # Adjust the toplevel makefile according to whether bootstrap was selected.
6238 case "$enable_bootstrap" in
6239   yes)
6240     bootstrap_suffix=bootstrap ;;
6241   no)
6242     bootstrap_suffix=no-bootstrap ;;
6243 esac
6244
6245 for module in ${build_configdirs} ; do
6246   if test -z "${no_recursion}" \
6247      && test -f ${build_subdir}/${module}/Makefile; then
6248     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6249     rm -f ${build_subdir}/${module}/Makefile
6250   fi
6251   extrasub="$extrasub
6252 /^@if build-$module\$/d
6253 /^@endif build-$module\$/d
6254 /^@if build-$module-$bootstrap_suffix\$/d
6255 /^@endif build-$module-$bootstrap_suffix\$/d"
6256 done
6257 for module in ${configdirs} ; do
6258   if test -z "${no_recursion}"; then
6259     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6260       if test -f ${file}; then
6261         echo 1>&2 "*** removing ${file} to force reconfigure"
6262         rm -f ${file}
6263       fi
6264     done
6265   fi
6266   extrasub="$extrasub
6267 /^@if $module\$/d
6268 /^@endif $module\$/d
6269 /^@if $module-$bootstrap_suffix\$/d
6270 /^@endif $module-$bootstrap_suffix\$/d"
6271 done
6272 for module in ${target_configdirs} ; do
6273   if test -z "${no_recursion}" \
6274      && test -f ${target_subdir}/${module}/Makefile; then
6275     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6276     rm -f ${target_subdir}/${module}/Makefile
6277   fi
6278   extrasub="$extrasub
6279 /^@if target-$module\$/d
6280 /^@endif target-$module\$/d
6281 /^@if target-$module-$bootstrap_suffix\$/d
6282 /^@endif target-$module-$bootstrap_suffix\$/d"
6283 done
6284
6285 extrasub="$extrasub
6286 /^@if /,/^@endif /d"
6287
6288 # Create the serialization dependencies.  This uses a temporary file.
6289
6290 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6291 if test "${enable_serial_configure+set}" = set; then
6292   enableval="$enable_serial_configure"
6293
6294 fi;
6295
6296 case ${enable_serial_configure} in
6297   yes)
6298     enable_serial_build_configure=yes
6299     enable_serial_host_configure=yes
6300     enable_serial_target_configure=yes
6301     ;;
6302 esac
6303
6304 # These force 'configure's to be done one at a time, to avoid problems
6305 # with contention over a shared config.cache.
6306 rm -f serdep.tmp
6307 echo '# serdep.tmp' > serdep.tmp
6308 olditem=
6309 test "x${enable_serial_build_configure}" = xyes &&
6310 for item in ${build_configdirs} ; do
6311   case ${olditem} in
6312     "") ;;
6313     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6314   esac
6315   olditem=${item}
6316 done
6317 olditem=
6318 test "x${enable_serial_host_configure}" = xyes &&
6319 for item in ${configdirs} ; do
6320   case ${olditem} in
6321     "") ;;
6322     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6323   esac
6324   olditem=${item}
6325 done
6326 olditem=
6327 test "x${enable_serial_target_configure}" = xyes &&
6328 for item in ${target_configdirs} ; do
6329   case ${olditem} in
6330     "") ;;
6331     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6332   esac
6333   olditem=${item}
6334 done
6335 serialization_dependencies=serdep.tmp
6336
6337
6338 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6339 # target, nonopt, and variable assignments.  These are the ones we
6340 # might not want to pass down to subconfigures.  Also strip
6341 # program-prefix, program-suffix, and program-transform-name, so that
6342 # we can pass down a consistent program-transform-name.
6343 baseargs=
6344 keep_next=no
6345 skip_next=no
6346 eval "set -- $ac_configure_args"
6347 for ac_arg
6348 do
6349   if test X"$skip_next" = X"yes"; then
6350     skip_next=no
6351     continue
6352   fi
6353   if test X"$keep_next" = X"yes"; then
6354     case $ac_arg in
6355       *\'*)
6356         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6357     esac
6358     baseargs="$baseargs '$ac_arg'"
6359     keep_next=no
6360     continue
6361   fi
6362
6363   # Handle separated arguments.  Based on the logic generated by
6364   # autoconf 2.59.
6365   case $ac_arg in
6366     *=* | --config-cache | -C | -disable-* | --disable-* \
6367       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6368       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6369       | -with-* | --with-* | -without-* | --without-* | --x)
6370       separate_arg=no
6371       ;;
6372     -*)
6373       separate_arg=yes
6374       ;;
6375     *)
6376       separate_arg=no
6377       ;;
6378   esac
6379
6380   case "$ac_arg" in
6381     --no*)
6382       continue
6383       ;;
6384     --c* | \
6385     --sr* | \
6386     --ho* | \
6387     --bu* | \
6388     --t* | \
6389     --program-* | \
6390     -cache_file* | \
6391     -srcdir* | \
6392     -host* | \
6393     -build* | \
6394     -target* | \
6395     -program-prefix* | \
6396     -program-suffix* | \
6397     -program-transform-name* )
6398       skip_next=$separate_arg
6399       continue
6400       ;;
6401     -*)
6402       # An option.  Add it.
6403       case $ac_arg in
6404         *\'*)
6405           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6406       esac
6407       baseargs="$baseargs '$ac_arg'"
6408       keep_next=$separate_arg
6409       ;;
6410     *)
6411       # Either a variable assignment, or a nonopt (triplet).  Don't
6412       # pass it down; let the Makefile handle this.
6413       continue
6414       ;;
6415   esac
6416 done
6417 # Remove the initial space we just introduced and, as these will be
6418 # expanded by make, quote '$'.
6419 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6420
6421 # Add in --program-transform-name, after --program-prefix and
6422 # --program-suffix have been applied to it.  Autoconf has already
6423 # doubled dollar signs and backslashes in program_transform_name; we want
6424 # the backslashes un-doubled, and then the entire thing wrapped in single
6425 # quotes, because this will be expanded first by make and then by the shell.
6426 # Also, because we want to override the logic in subdir configure scripts to
6427 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6428 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6429 ${program_transform_name}
6430 EOF_SED
6431 gcc_transform_name=`cat conftestsed.out`
6432 rm -f conftestsed.out
6433 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6434 if test "$silent" = yes; then
6435   baseargs="$baseargs --silent"
6436 fi
6437
6438 # For the build-side libraries, we just need to pretend we're native,
6439 # and not use the same cache file.  Multilibs are neither needed nor
6440 # desired.
6441 build_configargs="--cache-file=../config.cache ${baseargs}"
6442
6443 # For host modules, accept cache file option, or specification as blank.
6444 case "${cache_file}" in
6445 "") # empty
6446   cache_file_option="" ;;
6447 /* | [A-Za-z]:[\\/]* ) # absolute path
6448   cache_file_option="--cache-file=${cache_file}" ;;
6449 *) # relative path
6450   cache_file_option="--cache-file=../${cache_file}" ;;
6451 esac
6452
6453 # Host dirs don't like to share a cache file either, horribly enough.
6454 # This seems to be due to autoconf 2.5x stupidity.
6455 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6456
6457 target_configargs=${baseargs}
6458
6459 # Passing a --with-cross-host argument lets the target libraries know
6460 # whether they are being built with a cross-compiler or being built
6461 # native.  However, it would be better to use other mechanisms to make the
6462 # sorts of decisions they want to make on this basis.  Please consider
6463 # this option to be deprecated.  FIXME.
6464 if test x${is_cross_compiler} = xyes ; then
6465   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6466 fi
6467
6468 # Default to --enable-multilib.
6469 if test x${enable_multilib} = x ; then
6470   target_configargs="--enable-multilib ${target_configargs}"
6471 fi
6472
6473 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6474 # changed from the earlier setting of with_newlib.
6475 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6476   target_configargs="--with-newlib ${target_configargs}"
6477 fi
6478
6479 # Different target subdirs use different values of certain variables
6480 # (notably CXX).  Worse, multilibs use *lots* of different values.
6481 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6482 # it doesn't automatically accept command-line overrides of them.
6483 # This means it's not safe for target subdirs to share a cache file,
6484 # which is disgusting, but there you have it.  Hopefully this can be
6485 # fixed in future.  It's still worthwhile to use a cache file for each
6486 # directory.  I think.
6487
6488 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6489 # We need to pass --target, as newer autoconf's requires consistency
6490 # for target_alias and gcc doesn't manage it consistently.
6491 target_configargs="--cache-file=./config.cache ${target_configargs}"
6492
6493 FLAGS_FOR_TARGET=
6494 case " $target_configdirs " in
6495  *" newlib "*)
6496   case " $target_configargs " in
6497   *" --with-newlib "*)
6498    case "$target" in
6499    *-cygwin*)
6500      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' ;;
6501    esac
6502
6503    # If we're not building GCC, don't discard standard headers.
6504    if test -d ${srcdir}/gcc; then
6505      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6506
6507      if test "${build}" != "${host}"; then
6508        # On Canadian crosses, CC_FOR_TARGET will have already been set
6509        # by `configure', so we won't have an opportunity to add -Bgcc/
6510        # to it.  This is right: we don't want to search that directory
6511        # for binaries, but we want the header files in there, so add
6512        # them explicitly.
6513        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6514
6515        # Someone might think of using the pre-installed headers on
6516        # Canadian crosses, in case the installed compiler is not fully
6517        # compatible with the compiler being built.  In this case, it
6518        # would be better to flag an error than risking having
6519        # incompatible object files being constructed.  We can't
6520        # guarantee that an error will be flagged, but let's hope the
6521        # compiler will do it, when presented with incompatible header
6522        # files.
6523      fi
6524    fi
6525
6526    case "${target}-${is_cross_compiler}" in
6527    i[3456789]86-*-linux*-no)
6528       # Here host == target, so we don't need to build gcc,
6529       # so we don't want to discard standard headers.
6530       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6531       ;;
6532    *)
6533       # If we're building newlib, use its generic headers last, but search
6534       # for any libc-related directories first (so make it the last -B
6535       # switch).
6536       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6537
6538       # If we're building libgloss, find the startup file, simulator library
6539       # and linker script.
6540       case " $target_configdirs " in
6541         *" libgloss "*)
6542         # Look for startup file, simulator library and maybe linker script.
6543         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6544         # Look for libnosys.a in case the target needs it.
6545         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6546         # Most targets have the linker script in the source directory.
6547         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6548         ;;
6549       esac
6550       ;;
6551    esac
6552    ;;
6553   esac
6554   ;;
6555 esac
6556 case "$target" in
6557 *-mingw*)
6558   # Can't be handled as Cygwin above since Mingw does not use newlib.
6559   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' ;;
6560 esac
6561
6562 # Allow the user to override the flags for
6563 # our build compiler if desired.
6564 if test x"${build}" = x"${host}" ; then
6565   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6566   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6567   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6568 fi
6569
6570 # On Canadian crosses, we'll be searching the right directories for
6571 # the previously-installed cross compiler, so don't bother to add
6572 # flags for directories within the install tree of the compiler
6573 # being built; programs in there won't even run.
6574 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6575   # Search for pre-installed headers if nothing else fits.
6576   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6577 fi
6578
6579 if test "x${use_gnu_ld}" = x &&
6580    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6581   # Arrange for us to find uninstalled linker scripts.
6582   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6583 fi
6584
6585 # Search for other target-specific linker scripts and such.
6586 case "${target}" in
6587   mep*)
6588     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6589     ;;
6590 esac
6591
6592 # Makefile fragments.
6593 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6594 do
6595   eval fragval=\$$frag
6596   if test $fragval != /dev/null; then
6597     eval $frag=${srcdir}/$fragval
6598   fi
6599 done
6600
6601
6602
6603
6604
6605 # Miscellanea: directories, flags, etc.
6606
6607
6608
6609
6610
6611
6612
6613
6614 # Build module lists & subconfigure args.
6615
6616
6617
6618 # Host module lists & subconfigure args.
6619
6620
6621
6622 # Target module lists & subconfigure args.
6623
6624
6625
6626 # Build tools.
6627
6628
6629
6630
6631
6632
6633
6634
6635
6636
6637
6638
6639
6640
6641
6642
6643
6644 # Generate default definitions for YACC, M4, LEX and other programs that run
6645 # on the build machine.  These are used if the Makefile can't locate these
6646 # programs in objdir.
6647 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6648
6649 for ac_prog in 'bison -y' byacc yacc
6650 do
6651   # Extract the first word of "$ac_prog", so it can be a program name with args.
6652 set dummy $ac_prog; ac_word=$2
6653 echo "$as_me:$LINENO: checking for $ac_word" >&5
6654 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6655 if test "${ac_cv_prog_YACC+set}" = set; then
6656   echo $ECHO_N "(cached) $ECHO_C" >&6
6657 else
6658   if test -n "$YACC"; then
6659   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6660 else
6661 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6662 for as_dir in $PATH
6663 do
6664   IFS=$as_save_IFS
6665   test -z "$as_dir" && as_dir=.
6666   for ac_exec_ext in '' $ac_executable_extensions; do
6667   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6668     ac_cv_prog_YACC="$ac_prog"
6669     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6670     break 2
6671   fi
6672 done
6673 done
6674
6675 fi
6676 fi
6677 YACC=$ac_cv_prog_YACC
6678 if test -n "$YACC"; then
6679   echo "$as_me:$LINENO: result: $YACC" >&5
6680 echo "${ECHO_T}$YACC" >&6
6681 else
6682   echo "$as_me:$LINENO: result: no" >&5
6683 echo "${ECHO_T}no" >&6
6684 fi
6685
6686   test -n "$YACC" && break
6687 done
6688 test -n "$YACC" || YACC="$MISSING bison -y"
6689
6690 case " $build_configdirs " in
6691   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6692   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6693 esac
6694
6695 for ac_prog in bison
6696 do
6697   # Extract the first word of "$ac_prog", so it can be a program name with args.
6698 set dummy $ac_prog; ac_word=$2
6699 echo "$as_me:$LINENO: checking for $ac_word" >&5
6700 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6701 if test "${ac_cv_prog_BISON+set}" = set; then
6702   echo $ECHO_N "(cached) $ECHO_C" >&6
6703 else
6704   if test -n "$BISON"; then
6705   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6706 else
6707 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6708 for as_dir in $PATH
6709 do
6710   IFS=$as_save_IFS
6711   test -z "$as_dir" && as_dir=.
6712   for ac_exec_ext in '' $ac_executable_extensions; do
6713   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6714     ac_cv_prog_BISON="$ac_prog"
6715     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6716     break 2
6717   fi
6718 done
6719 done
6720
6721 fi
6722 fi
6723 BISON=$ac_cv_prog_BISON
6724 if test -n "$BISON"; then
6725   echo "$as_me:$LINENO: result: $BISON" >&5
6726 echo "${ECHO_T}$BISON" >&6
6727 else
6728   echo "$as_me:$LINENO: result: no" >&5
6729 echo "${ECHO_T}no" >&6
6730 fi
6731
6732   test -n "$BISON" && break
6733 done
6734 test -n "$BISON" || BISON="$MISSING bison"
6735
6736 case " $build_configdirs " in
6737   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6738 esac
6739
6740 for ac_prog in gm4 gnum4 m4
6741 do
6742   # Extract the first word of "$ac_prog", so it can be a program name with args.
6743 set dummy $ac_prog; ac_word=$2
6744 echo "$as_me:$LINENO: checking for $ac_word" >&5
6745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6746 if test "${ac_cv_prog_M4+set}" = set; then
6747   echo $ECHO_N "(cached) $ECHO_C" >&6
6748 else
6749   if test -n "$M4"; then
6750   ac_cv_prog_M4="$M4" # Let the user override the test.
6751 else
6752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6753 for as_dir in $PATH
6754 do
6755   IFS=$as_save_IFS
6756   test -z "$as_dir" && as_dir=.
6757   for ac_exec_ext in '' $ac_executable_extensions; do
6758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6759     ac_cv_prog_M4="$ac_prog"
6760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6761     break 2
6762   fi
6763 done
6764 done
6765
6766 fi
6767 fi
6768 M4=$ac_cv_prog_M4
6769 if test -n "$M4"; then
6770   echo "$as_me:$LINENO: result: $M4" >&5
6771 echo "${ECHO_T}$M4" >&6
6772 else
6773   echo "$as_me:$LINENO: result: no" >&5
6774 echo "${ECHO_T}no" >&6
6775 fi
6776
6777   test -n "$M4" && break
6778 done
6779 test -n "$M4" || M4="$MISSING m4"
6780
6781 case " $build_configdirs " in
6782   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6783 esac
6784
6785 for ac_prog in flex lex
6786 do
6787   # Extract the first word of "$ac_prog", so it can be a program name with args.
6788 set dummy $ac_prog; ac_word=$2
6789 echo "$as_me:$LINENO: checking for $ac_word" >&5
6790 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6791 if test "${ac_cv_prog_LEX+set}" = set; then
6792   echo $ECHO_N "(cached) $ECHO_C" >&6
6793 else
6794   if test -n "$LEX"; then
6795   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6796 else
6797 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6798 for as_dir in $PATH
6799 do
6800   IFS=$as_save_IFS
6801   test -z "$as_dir" && as_dir=.
6802   for ac_exec_ext in '' $ac_executable_extensions; do
6803   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6804     ac_cv_prog_LEX="$ac_prog"
6805     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6806     break 2
6807   fi
6808 done
6809 done
6810
6811 fi
6812 fi
6813 LEX=$ac_cv_prog_LEX
6814 if test -n "$LEX"; then
6815   echo "$as_me:$LINENO: result: $LEX" >&5
6816 echo "${ECHO_T}$LEX" >&6
6817 else
6818   echo "$as_me:$LINENO: result: no" >&5
6819 echo "${ECHO_T}no" >&6
6820 fi
6821
6822   test -n "$LEX" && break
6823 done
6824 test -n "$LEX" || LEX="$MISSING flex"
6825
6826 case " $build_configdirs " in
6827   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6828   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6829 esac
6830
6831 for ac_prog in flex
6832 do
6833   # Extract the first word of "$ac_prog", so it can be a program name with args.
6834 set dummy $ac_prog; ac_word=$2
6835 echo "$as_me:$LINENO: checking for $ac_word" >&5
6836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6837 if test "${ac_cv_prog_FLEX+set}" = set; then
6838   echo $ECHO_N "(cached) $ECHO_C" >&6
6839 else
6840   if test -n "$FLEX"; then
6841   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6842 else
6843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6844 for as_dir in $PATH
6845 do
6846   IFS=$as_save_IFS
6847   test -z "$as_dir" && as_dir=.
6848   for ac_exec_ext in '' $ac_executable_extensions; do
6849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6850     ac_cv_prog_FLEX="$ac_prog"
6851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6852     break 2
6853   fi
6854 done
6855 done
6856
6857 fi
6858 fi
6859 FLEX=$ac_cv_prog_FLEX
6860 if test -n "$FLEX"; then
6861   echo "$as_me:$LINENO: result: $FLEX" >&5
6862 echo "${ECHO_T}$FLEX" >&6
6863 else
6864   echo "$as_me:$LINENO: result: no" >&5
6865 echo "${ECHO_T}no" >&6
6866 fi
6867
6868   test -n "$FLEX" && break
6869 done
6870 test -n "$FLEX" || FLEX="$MISSING flex"
6871
6872 case " $build_configdirs " in
6873   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6874 esac
6875
6876 for ac_prog in makeinfo
6877 do
6878   # Extract the first word of "$ac_prog", so it can be a program name with args.
6879 set dummy $ac_prog; ac_word=$2
6880 echo "$as_me:$LINENO: checking for $ac_word" >&5
6881 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6882 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6883   echo $ECHO_N "(cached) $ECHO_C" >&6
6884 else
6885   if test -n "$MAKEINFO"; then
6886   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6887 else
6888 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6889 for as_dir in $PATH
6890 do
6891   IFS=$as_save_IFS
6892   test -z "$as_dir" && as_dir=.
6893   for ac_exec_ext in '' $ac_executable_extensions; do
6894   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6895     ac_cv_prog_MAKEINFO="$ac_prog"
6896     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6897     break 2
6898   fi
6899 done
6900 done
6901
6902 fi
6903 fi
6904 MAKEINFO=$ac_cv_prog_MAKEINFO
6905 if test -n "$MAKEINFO"; then
6906   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6907 echo "${ECHO_T}$MAKEINFO" >&6
6908 else
6909   echo "$as_me:$LINENO: result: no" >&5
6910 echo "${ECHO_T}no" >&6
6911 fi
6912
6913   test -n "$MAKEINFO" && break
6914 done
6915 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6916
6917 case " $build_configdirs " in
6918   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6919   *)
6920
6921     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6922     # higher, else we use the "missing" dummy.
6923     if ${MAKEINFO} --version \
6924        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6925       :
6926     else
6927       MAKEINFO="$MISSING makeinfo"
6928     fi
6929     ;;
6930
6931 esac
6932
6933 # FIXME: expect and dejagnu may become build tools?
6934
6935 for ac_prog in expect
6936 do
6937   # Extract the first word of "$ac_prog", so it can be a program name with args.
6938 set dummy $ac_prog; ac_word=$2
6939 echo "$as_me:$LINENO: checking for $ac_word" >&5
6940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6941 if test "${ac_cv_prog_EXPECT+set}" = set; then
6942   echo $ECHO_N "(cached) $ECHO_C" >&6
6943 else
6944   if test -n "$EXPECT"; then
6945   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6946 else
6947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6948 for as_dir in $PATH
6949 do
6950   IFS=$as_save_IFS
6951   test -z "$as_dir" && as_dir=.
6952   for ac_exec_ext in '' $ac_executable_extensions; do
6953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6954     ac_cv_prog_EXPECT="$ac_prog"
6955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6956     break 2
6957   fi
6958 done
6959 done
6960
6961 fi
6962 fi
6963 EXPECT=$ac_cv_prog_EXPECT
6964 if test -n "$EXPECT"; then
6965   echo "$as_me:$LINENO: result: $EXPECT" >&5
6966 echo "${ECHO_T}$EXPECT" >&6
6967 else
6968   echo "$as_me:$LINENO: result: no" >&5
6969 echo "${ECHO_T}no" >&6
6970 fi
6971
6972   test -n "$EXPECT" && break
6973 done
6974 test -n "$EXPECT" || EXPECT="expect"
6975
6976 case " $configdirs " in
6977   *" expect "*)
6978     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6979     ;;
6980 esac
6981
6982 for ac_prog in runtest
6983 do
6984   # Extract the first word of "$ac_prog", so it can be a program name with args.
6985 set dummy $ac_prog; ac_word=$2
6986 echo "$as_me:$LINENO: checking for $ac_word" >&5
6987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6988 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6989   echo $ECHO_N "(cached) $ECHO_C" >&6
6990 else
6991   if test -n "$RUNTEST"; then
6992   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6993 else
6994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6995 for as_dir in $PATH
6996 do
6997   IFS=$as_save_IFS
6998   test -z "$as_dir" && as_dir=.
6999   for ac_exec_ext in '' $ac_executable_extensions; do
7000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7001     ac_cv_prog_RUNTEST="$ac_prog"
7002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7003     break 2
7004   fi
7005 done
7006 done
7007
7008 fi
7009 fi
7010 RUNTEST=$ac_cv_prog_RUNTEST
7011 if test -n "$RUNTEST"; then
7012   echo "$as_me:$LINENO: result: $RUNTEST" >&5
7013 echo "${ECHO_T}$RUNTEST" >&6
7014 else
7015   echo "$as_me:$LINENO: result: no" >&5
7016 echo "${ECHO_T}no" >&6
7017 fi
7018
7019   test -n "$RUNTEST" && break
7020 done
7021 test -n "$RUNTEST" || RUNTEST="runtest"
7022
7023 case " $configdirs " in
7024   *" dejagnu "*)
7025     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
7026     ;;
7027 esac
7028
7029
7030 # Host tools.
7031 ncn_tool_prefix=
7032 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
7033 ncn_target_tool_prefix=
7034 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
7035
7036
7037
7038 if test -n "$AR"; then
7039   ac_cv_prog_AR=$AR
7040 elif test -n "$ac_cv_prog_AR"; then
7041   AR=$ac_cv_prog_AR
7042 fi
7043
7044 if test -n "$ac_cv_prog_AR"; then
7045   for ncn_progname in ar; do
7046     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7047 set dummy ${ncn_progname}; ac_word=$2
7048 echo "$as_me:$LINENO: checking for $ac_word" >&5
7049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7050 if test "${ac_cv_prog_AR+set}" = set; then
7051   echo $ECHO_N "(cached) $ECHO_C" >&6
7052 else
7053   if test -n "$AR"; then
7054   ac_cv_prog_AR="$AR" # Let the user override the test.
7055 else
7056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7057 for as_dir in $PATH
7058 do
7059   IFS=$as_save_IFS
7060   test -z "$as_dir" && as_dir=.
7061   for ac_exec_ext in '' $ac_executable_extensions; do
7062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7063     ac_cv_prog_AR="${ncn_progname}"
7064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7065     break 2
7066   fi
7067 done
7068 done
7069
7070 fi
7071 fi
7072 AR=$ac_cv_prog_AR
7073 if test -n "$AR"; then
7074   echo "$as_me:$LINENO: result: $AR" >&5
7075 echo "${ECHO_T}$AR" >&6
7076 else
7077   echo "$as_me:$LINENO: result: no" >&5
7078 echo "${ECHO_T}no" >&6
7079 fi
7080
7081   done
7082 fi
7083
7084 for ncn_progname in ar; do
7085   if test -n "$ncn_tool_prefix"; then
7086     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7087 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7088 echo "$as_me:$LINENO: checking for $ac_word" >&5
7089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7090 if test "${ac_cv_prog_AR+set}" = set; then
7091   echo $ECHO_N "(cached) $ECHO_C" >&6
7092 else
7093   if test -n "$AR"; then
7094   ac_cv_prog_AR="$AR" # Let the user override the test.
7095 else
7096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7097 for as_dir in $PATH
7098 do
7099   IFS=$as_save_IFS
7100   test -z "$as_dir" && as_dir=.
7101   for ac_exec_ext in '' $ac_executable_extensions; do
7102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7103     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
7104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7105     break 2
7106   fi
7107 done
7108 done
7109
7110 fi
7111 fi
7112 AR=$ac_cv_prog_AR
7113 if test -n "$AR"; then
7114   echo "$as_me:$LINENO: result: $AR" >&5
7115 echo "${ECHO_T}$AR" >&6
7116 else
7117   echo "$as_me:$LINENO: result: no" >&5
7118 echo "${ECHO_T}no" >&6
7119 fi
7120
7121   fi
7122   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
7123     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7124 set dummy ${ncn_progname}; ac_word=$2
7125 echo "$as_me:$LINENO: checking for $ac_word" >&5
7126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7127 if test "${ac_cv_prog_AR+set}" = set; then
7128   echo $ECHO_N "(cached) $ECHO_C" >&6
7129 else
7130   if test -n "$AR"; then
7131   ac_cv_prog_AR="$AR" # Let the user override the test.
7132 else
7133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7134 for as_dir in $PATH
7135 do
7136   IFS=$as_save_IFS
7137   test -z "$as_dir" && as_dir=.
7138   for ac_exec_ext in '' $ac_executable_extensions; do
7139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7140     ac_cv_prog_AR="${ncn_progname}"
7141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7142     break 2
7143   fi
7144 done
7145 done
7146
7147 fi
7148 fi
7149 AR=$ac_cv_prog_AR
7150 if test -n "$AR"; then
7151   echo "$as_me:$LINENO: result: $AR" >&5
7152 echo "${ECHO_T}$AR" >&6
7153 else
7154   echo "$as_me:$LINENO: result: no" >&5
7155 echo "${ECHO_T}no" >&6
7156 fi
7157
7158   fi
7159   test -n "$ac_cv_prog_AR" && break
7160 done
7161
7162 if test -z "$ac_cv_prog_AR" ; then
7163   set dummy ar
7164   if test $build = $host ; then
7165     AR="$2"
7166   else
7167     AR="${ncn_tool_prefix}$2"
7168   fi
7169 fi
7170
7171
7172
7173 if test -n "$AS"; then
7174   ac_cv_prog_AS=$AS
7175 elif test -n "$ac_cv_prog_AS"; then
7176   AS=$ac_cv_prog_AS
7177 fi
7178
7179 if test -n "$ac_cv_prog_AS"; then
7180   for ncn_progname in as; do
7181     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7182 set dummy ${ncn_progname}; ac_word=$2
7183 echo "$as_me:$LINENO: checking for $ac_word" >&5
7184 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7185 if test "${ac_cv_prog_AS+set}" = set; then
7186   echo $ECHO_N "(cached) $ECHO_C" >&6
7187 else
7188   if test -n "$AS"; then
7189   ac_cv_prog_AS="$AS" # Let the user override the test.
7190 else
7191 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7192 for as_dir in $PATH
7193 do
7194   IFS=$as_save_IFS
7195   test -z "$as_dir" && as_dir=.
7196   for ac_exec_ext in '' $ac_executable_extensions; do
7197   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7198     ac_cv_prog_AS="${ncn_progname}"
7199     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7200     break 2
7201   fi
7202 done
7203 done
7204
7205 fi
7206 fi
7207 AS=$ac_cv_prog_AS
7208 if test -n "$AS"; then
7209   echo "$as_me:$LINENO: result: $AS" >&5
7210 echo "${ECHO_T}$AS" >&6
7211 else
7212   echo "$as_me:$LINENO: result: no" >&5
7213 echo "${ECHO_T}no" >&6
7214 fi
7215
7216   done
7217 fi
7218
7219 for ncn_progname in as; do
7220   if test -n "$ncn_tool_prefix"; then
7221     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7222 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7223 echo "$as_me:$LINENO: checking for $ac_word" >&5
7224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7225 if test "${ac_cv_prog_AS+set}" = set; then
7226   echo $ECHO_N "(cached) $ECHO_C" >&6
7227 else
7228   if test -n "$AS"; then
7229   ac_cv_prog_AS="$AS" # Let the user override the test.
7230 else
7231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7232 for as_dir in $PATH
7233 do
7234   IFS=$as_save_IFS
7235   test -z "$as_dir" && as_dir=.
7236   for ac_exec_ext in '' $ac_executable_extensions; do
7237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7238     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
7239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7240     break 2
7241   fi
7242 done
7243 done
7244
7245 fi
7246 fi
7247 AS=$ac_cv_prog_AS
7248 if test -n "$AS"; then
7249   echo "$as_me:$LINENO: result: $AS" >&5
7250 echo "${ECHO_T}$AS" >&6
7251 else
7252   echo "$as_me:$LINENO: result: no" >&5
7253 echo "${ECHO_T}no" >&6
7254 fi
7255
7256   fi
7257   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7258     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7259 set dummy ${ncn_progname}; ac_word=$2
7260 echo "$as_me:$LINENO: checking for $ac_word" >&5
7261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7262 if test "${ac_cv_prog_AS+set}" = set; then
7263   echo $ECHO_N "(cached) $ECHO_C" >&6
7264 else
7265   if test -n "$AS"; then
7266   ac_cv_prog_AS="$AS" # Let the user override the test.
7267 else
7268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7269 for as_dir in $PATH
7270 do
7271   IFS=$as_save_IFS
7272   test -z "$as_dir" && as_dir=.
7273   for ac_exec_ext in '' $ac_executable_extensions; do
7274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7275     ac_cv_prog_AS="${ncn_progname}"
7276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7277     break 2
7278   fi
7279 done
7280 done
7281
7282 fi
7283 fi
7284 AS=$ac_cv_prog_AS
7285 if test -n "$AS"; then
7286   echo "$as_me:$LINENO: result: $AS" >&5
7287 echo "${ECHO_T}$AS" >&6
7288 else
7289   echo "$as_me:$LINENO: result: no" >&5
7290 echo "${ECHO_T}no" >&6
7291 fi
7292
7293   fi
7294   test -n "$ac_cv_prog_AS" && break
7295 done
7296
7297 if test -z "$ac_cv_prog_AS" ; then
7298   set dummy as
7299   if test $build = $host ; then
7300     AS="$2"
7301   else
7302     AS="${ncn_tool_prefix}$2"
7303   fi
7304 fi
7305
7306
7307
7308 if test -n "$DLLTOOL"; then
7309   ac_cv_prog_DLLTOOL=$DLLTOOL
7310 elif test -n "$ac_cv_prog_DLLTOOL"; then
7311   DLLTOOL=$ac_cv_prog_DLLTOOL
7312 fi
7313
7314 if test -n "$ac_cv_prog_DLLTOOL"; then
7315   for ncn_progname in dlltool; do
7316     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7317 set dummy ${ncn_progname}; ac_word=$2
7318 echo "$as_me:$LINENO: checking for $ac_word" >&5
7319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7320 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7321   echo $ECHO_N "(cached) $ECHO_C" >&6
7322 else
7323   if test -n "$DLLTOOL"; then
7324   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7325 else
7326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7327 for as_dir in $PATH
7328 do
7329   IFS=$as_save_IFS
7330   test -z "$as_dir" && as_dir=.
7331   for ac_exec_ext in '' $ac_executable_extensions; do
7332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7333     ac_cv_prog_DLLTOOL="${ncn_progname}"
7334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7335     break 2
7336   fi
7337 done
7338 done
7339
7340 fi
7341 fi
7342 DLLTOOL=$ac_cv_prog_DLLTOOL
7343 if test -n "$DLLTOOL"; then
7344   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7345 echo "${ECHO_T}$DLLTOOL" >&6
7346 else
7347   echo "$as_me:$LINENO: result: no" >&5
7348 echo "${ECHO_T}no" >&6
7349 fi
7350
7351   done
7352 fi
7353
7354 for ncn_progname in dlltool; do
7355   if test -n "$ncn_tool_prefix"; then
7356     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7357 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7358 echo "$as_me:$LINENO: checking for $ac_word" >&5
7359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7360 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7361   echo $ECHO_N "(cached) $ECHO_C" >&6
7362 else
7363   if test -n "$DLLTOOL"; then
7364   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7365 else
7366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7367 for as_dir in $PATH
7368 do
7369   IFS=$as_save_IFS
7370   test -z "$as_dir" && as_dir=.
7371   for ac_exec_ext in '' $ac_executable_extensions; do
7372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7373     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7375     break 2
7376   fi
7377 done
7378 done
7379
7380 fi
7381 fi
7382 DLLTOOL=$ac_cv_prog_DLLTOOL
7383 if test -n "$DLLTOOL"; then
7384   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7385 echo "${ECHO_T}$DLLTOOL" >&6
7386 else
7387   echo "$as_me:$LINENO: result: no" >&5
7388 echo "${ECHO_T}no" >&6
7389 fi
7390
7391   fi
7392   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7393     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7394 set dummy ${ncn_progname}; ac_word=$2
7395 echo "$as_me:$LINENO: checking for $ac_word" >&5
7396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7397 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7398   echo $ECHO_N "(cached) $ECHO_C" >&6
7399 else
7400   if test -n "$DLLTOOL"; then
7401   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7402 else
7403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7404 for as_dir in $PATH
7405 do
7406   IFS=$as_save_IFS
7407   test -z "$as_dir" && as_dir=.
7408   for ac_exec_ext in '' $ac_executable_extensions; do
7409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7410     ac_cv_prog_DLLTOOL="${ncn_progname}"
7411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7412     break 2
7413   fi
7414 done
7415 done
7416
7417 fi
7418 fi
7419 DLLTOOL=$ac_cv_prog_DLLTOOL
7420 if test -n "$DLLTOOL"; then
7421   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7422 echo "${ECHO_T}$DLLTOOL" >&6
7423 else
7424   echo "$as_me:$LINENO: result: no" >&5
7425 echo "${ECHO_T}no" >&6
7426 fi
7427
7428   fi
7429   test -n "$ac_cv_prog_DLLTOOL" && break
7430 done
7431
7432 if test -z "$ac_cv_prog_DLLTOOL" ; then
7433   set dummy dlltool
7434   if test $build = $host ; then
7435     DLLTOOL="$2"
7436   else
7437     DLLTOOL="${ncn_tool_prefix}$2"
7438   fi
7439 fi
7440
7441
7442
7443 if test -n "$LD"; then
7444   ac_cv_prog_LD=$LD
7445 elif test -n "$ac_cv_prog_LD"; then
7446   LD=$ac_cv_prog_LD
7447 fi
7448
7449 if test -n "$ac_cv_prog_LD"; then
7450   for ncn_progname in ld; do
7451     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7452 set dummy ${ncn_progname}; ac_word=$2
7453 echo "$as_me:$LINENO: checking for $ac_word" >&5
7454 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7455 if test "${ac_cv_prog_LD+set}" = set; then
7456   echo $ECHO_N "(cached) $ECHO_C" >&6
7457 else
7458   if test -n "$LD"; then
7459   ac_cv_prog_LD="$LD" # Let the user override the test.
7460 else
7461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7462 for as_dir in $PATH
7463 do
7464   IFS=$as_save_IFS
7465   test -z "$as_dir" && as_dir=.
7466   for ac_exec_ext in '' $ac_executable_extensions; do
7467   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7468     ac_cv_prog_LD="${ncn_progname}"
7469     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7470     break 2
7471   fi
7472 done
7473 done
7474
7475 fi
7476 fi
7477 LD=$ac_cv_prog_LD
7478 if test -n "$LD"; then
7479   echo "$as_me:$LINENO: result: $LD" >&5
7480 echo "${ECHO_T}$LD" >&6
7481 else
7482   echo "$as_me:$LINENO: result: no" >&5
7483 echo "${ECHO_T}no" >&6
7484 fi
7485
7486   done
7487 fi
7488
7489 for ncn_progname in ld; do
7490   if test -n "$ncn_tool_prefix"; then
7491     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7492 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7493 echo "$as_me:$LINENO: checking for $ac_word" >&5
7494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7495 if test "${ac_cv_prog_LD+set}" = set; then
7496   echo $ECHO_N "(cached) $ECHO_C" >&6
7497 else
7498   if test -n "$LD"; then
7499   ac_cv_prog_LD="$LD" # Let the user override the test.
7500 else
7501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7502 for as_dir in $PATH
7503 do
7504   IFS=$as_save_IFS
7505   test -z "$as_dir" && as_dir=.
7506   for ac_exec_ext in '' $ac_executable_extensions; do
7507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7508     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7510     break 2
7511   fi
7512 done
7513 done
7514
7515 fi
7516 fi
7517 LD=$ac_cv_prog_LD
7518 if test -n "$LD"; then
7519   echo "$as_me:$LINENO: result: $LD" >&5
7520 echo "${ECHO_T}$LD" >&6
7521 else
7522   echo "$as_me:$LINENO: result: no" >&5
7523 echo "${ECHO_T}no" >&6
7524 fi
7525
7526   fi
7527   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7528     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7529 set dummy ${ncn_progname}; ac_word=$2
7530 echo "$as_me:$LINENO: checking for $ac_word" >&5
7531 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7532 if test "${ac_cv_prog_LD+set}" = set; then
7533   echo $ECHO_N "(cached) $ECHO_C" >&6
7534 else
7535   if test -n "$LD"; then
7536   ac_cv_prog_LD="$LD" # Let the user override the test.
7537 else
7538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7539 for as_dir in $PATH
7540 do
7541   IFS=$as_save_IFS
7542   test -z "$as_dir" && as_dir=.
7543   for ac_exec_ext in '' $ac_executable_extensions; do
7544   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7545     ac_cv_prog_LD="${ncn_progname}"
7546     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7547     break 2
7548   fi
7549 done
7550 done
7551
7552 fi
7553 fi
7554 LD=$ac_cv_prog_LD
7555 if test -n "$LD"; then
7556   echo "$as_me:$LINENO: result: $LD" >&5
7557 echo "${ECHO_T}$LD" >&6
7558 else
7559   echo "$as_me:$LINENO: result: no" >&5
7560 echo "${ECHO_T}no" >&6
7561 fi
7562
7563   fi
7564   test -n "$ac_cv_prog_LD" && break
7565 done
7566
7567 if test -z "$ac_cv_prog_LD" ; then
7568   set dummy ld
7569   if test $build = $host ; then
7570     LD="$2"
7571   else
7572     LD="${ncn_tool_prefix}$2"
7573   fi
7574 fi
7575
7576
7577
7578 if test -n "$LIPO"; then
7579   ac_cv_prog_LIPO=$LIPO
7580 elif test -n "$ac_cv_prog_LIPO"; then
7581   LIPO=$ac_cv_prog_LIPO
7582 fi
7583
7584 if test -n "$ac_cv_prog_LIPO"; then
7585   for ncn_progname in lipo; do
7586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7587 set dummy ${ncn_progname}; ac_word=$2
7588 echo "$as_me:$LINENO: checking for $ac_word" >&5
7589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7590 if test "${ac_cv_prog_LIPO+set}" = set; then
7591   echo $ECHO_N "(cached) $ECHO_C" >&6
7592 else
7593   if test -n "$LIPO"; then
7594   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7595 else
7596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7597 for as_dir in $PATH
7598 do
7599   IFS=$as_save_IFS
7600   test -z "$as_dir" && as_dir=.
7601   for ac_exec_ext in '' $ac_executable_extensions; do
7602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7603     ac_cv_prog_LIPO="${ncn_progname}"
7604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7605     break 2
7606   fi
7607 done
7608 done
7609
7610 fi
7611 fi
7612 LIPO=$ac_cv_prog_LIPO
7613 if test -n "$LIPO"; then
7614   echo "$as_me:$LINENO: result: $LIPO" >&5
7615 echo "${ECHO_T}$LIPO" >&6
7616 else
7617   echo "$as_me:$LINENO: result: no" >&5
7618 echo "${ECHO_T}no" >&6
7619 fi
7620
7621   done
7622 fi
7623
7624 for ncn_progname in lipo; do
7625   if test -n "$ncn_tool_prefix"; then
7626     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7627 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7628 echo "$as_me:$LINENO: checking for $ac_word" >&5
7629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7630 if test "${ac_cv_prog_LIPO+set}" = set; then
7631   echo $ECHO_N "(cached) $ECHO_C" >&6
7632 else
7633   if test -n "$LIPO"; then
7634   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7635 else
7636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7637 for as_dir in $PATH
7638 do
7639   IFS=$as_save_IFS
7640   test -z "$as_dir" && as_dir=.
7641   for ac_exec_ext in '' $ac_executable_extensions; do
7642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7643     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7645     break 2
7646   fi
7647 done
7648 done
7649
7650 fi
7651 fi
7652 LIPO=$ac_cv_prog_LIPO
7653 if test -n "$LIPO"; then
7654   echo "$as_me:$LINENO: result: $LIPO" >&5
7655 echo "${ECHO_T}$LIPO" >&6
7656 else
7657   echo "$as_me:$LINENO: result: no" >&5
7658 echo "${ECHO_T}no" >&6
7659 fi
7660
7661   fi
7662   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7663     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7664 set dummy ${ncn_progname}; ac_word=$2
7665 echo "$as_me:$LINENO: checking for $ac_word" >&5
7666 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7667 if test "${ac_cv_prog_LIPO+set}" = set; then
7668   echo $ECHO_N "(cached) $ECHO_C" >&6
7669 else
7670   if test -n "$LIPO"; then
7671   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7672 else
7673 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7674 for as_dir in $PATH
7675 do
7676   IFS=$as_save_IFS
7677   test -z "$as_dir" && as_dir=.
7678   for ac_exec_ext in '' $ac_executable_extensions; do
7679   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7680     ac_cv_prog_LIPO="${ncn_progname}"
7681     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7682     break 2
7683   fi
7684 done
7685 done
7686
7687 fi
7688 fi
7689 LIPO=$ac_cv_prog_LIPO
7690 if test -n "$LIPO"; then
7691   echo "$as_me:$LINENO: result: $LIPO" >&5
7692 echo "${ECHO_T}$LIPO" >&6
7693 else
7694   echo "$as_me:$LINENO: result: no" >&5
7695 echo "${ECHO_T}no" >&6
7696 fi
7697
7698   fi
7699   test -n "$ac_cv_prog_LIPO" && break
7700 done
7701
7702 if test -z "$ac_cv_prog_LIPO" ; then
7703   set dummy lipo
7704   if test $build = $host ; then
7705     LIPO="$2"
7706   else
7707     LIPO="${ncn_tool_prefix}$2"
7708   fi
7709 fi
7710
7711
7712
7713 if test -n "$NM"; then
7714   ac_cv_prog_NM=$NM
7715 elif test -n "$ac_cv_prog_NM"; then
7716   NM=$ac_cv_prog_NM
7717 fi
7718
7719 if test -n "$ac_cv_prog_NM"; then
7720   for ncn_progname in nm; do
7721     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7722 set dummy ${ncn_progname}; ac_word=$2
7723 echo "$as_me:$LINENO: checking for $ac_word" >&5
7724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7725 if test "${ac_cv_prog_NM+set}" = set; then
7726   echo $ECHO_N "(cached) $ECHO_C" >&6
7727 else
7728   if test -n "$NM"; then
7729   ac_cv_prog_NM="$NM" # Let the user override the test.
7730 else
7731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7732 for as_dir in $PATH
7733 do
7734   IFS=$as_save_IFS
7735   test -z "$as_dir" && as_dir=.
7736   for ac_exec_ext in '' $ac_executable_extensions; do
7737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7738     ac_cv_prog_NM="${ncn_progname}"
7739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7740     break 2
7741   fi
7742 done
7743 done
7744
7745 fi
7746 fi
7747 NM=$ac_cv_prog_NM
7748 if test -n "$NM"; then
7749   echo "$as_me:$LINENO: result: $NM" >&5
7750 echo "${ECHO_T}$NM" >&6
7751 else
7752   echo "$as_me:$LINENO: result: no" >&5
7753 echo "${ECHO_T}no" >&6
7754 fi
7755
7756   done
7757 fi
7758
7759 for ncn_progname in nm; do
7760   if test -n "$ncn_tool_prefix"; then
7761     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7762 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7763 echo "$as_me:$LINENO: checking for $ac_word" >&5
7764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7765 if test "${ac_cv_prog_NM+set}" = set; then
7766   echo $ECHO_N "(cached) $ECHO_C" >&6
7767 else
7768   if test -n "$NM"; then
7769   ac_cv_prog_NM="$NM" # Let the user override the test.
7770 else
7771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7772 for as_dir in $PATH
7773 do
7774   IFS=$as_save_IFS
7775   test -z "$as_dir" && as_dir=.
7776   for ac_exec_ext in '' $ac_executable_extensions; do
7777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7778     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7780     break 2
7781   fi
7782 done
7783 done
7784
7785 fi
7786 fi
7787 NM=$ac_cv_prog_NM
7788 if test -n "$NM"; then
7789   echo "$as_me:$LINENO: result: $NM" >&5
7790 echo "${ECHO_T}$NM" >&6
7791 else
7792   echo "$as_me:$LINENO: result: no" >&5
7793 echo "${ECHO_T}no" >&6
7794 fi
7795
7796   fi
7797   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7798     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7799 set dummy ${ncn_progname}; ac_word=$2
7800 echo "$as_me:$LINENO: checking for $ac_word" >&5
7801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7802 if test "${ac_cv_prog_NM+set}" = set; then
7803   echo $ECHO_N "(cached) $ECHO_C" >&6
7804 else
7805   if test -n "$NM"; then
7806   ac_cv_prog_NM="$NM" # Let the user override the test.
7807 else
7808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7809 for as_dir in $PATH
7810 do
7811   IFS=$as_save_IFS
7812   test -z "$as_dir" && as_dir=.
7813   for ac_exec_ext in '' $ac_executable_extensions; do
7814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7815     ac_cv_prog_NM="${ncn_progname}"
7816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7817     break 2
7818   fi
7819 done
7820 done
7821
7822 fi
7823 fi
7824 NM=$ac_cv_prog_NM
7825 if test -n "$NM"; then
7826   echo "$as_me:$LINENO: result: $NM" >&5
7827 echo "${ECHO_T}$NM" >&6
7828 else
7829   echo "$as_me:$LINENO: result: no" >&5
7830 echo "${ECHO_T}no" >&6
7831 fi
7832
7833   fi
7834   test -n "$ac_cv_prog_NM" && break
7835 done
7836
7837 if test -z "$ac_cv_prog_NM" ; then
7838   set dummy nm
7839   if test $build = $host ; then
7840     NM="$2"
7841   else
7842     NM="${ncn_tool_prefix}$2"
7843   fi
7844 fi
7845
7846
7847
7848 if test -n "$RANLIB"; then
7849   ac_cv_prog_RANLIB=$RANLIB
7850 elif test -n "$ac_cv_prog_RANLIB"; then
7851   RANLIB=$ac_cv_prog_RANLIB
7852 fi
7853
7854 if test -n "$ac_cv_prog_RANLIB"; then
7855   for ncn_progname in ranlib; do
7856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7857 set dummy ${ncn_progname}; ac_word=$2
7858 echo "$as_me:$LINENO: checking for $ac_word" >&5
7859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7860 if test "${ac_cv_prog_RANLIB+set}" = set; then
7861   echo $ECHO_N "(cached) $ECHO_C" >&6
7862 else
7863   if test -n "$RANLIB"; then
7864   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7865 else
7866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7867 for as_dir in $PATH
7868 do
7869   IFS=$as_save_IFS
7870   test -z "$as_dir" && as_dir=.
7871   for ac_exec_ext in '' $ac_executable_extensions; do
7872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7873     ac_cv_prog_RANLIB="${ncn_progname}"
7874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7875     break 2
7876   fi
7877 done
7878 done
7879
7880 fi
7881 fi
7882 RANLIB=$ac_cv_prog_RANLIB
7883 if test -n "$RANLIB"; then
7884   echo "$as_me:$LINENO: result: $RANLIB" >&5
7885 echo "${ECHO_T}$RANLIB" >&6
7886 else
7887   echo "$as_me:$LINENO: result: no" >&5
7888 echo "${ECHO_T}no" >&6
7889 fi
7890
7891   done
7892 fi
7893
7894 for ncn_progname in ranlib; do
7895   if test -n "$ncn_tool_prefix"; then
7896     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7897 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7898 echo "$as_me:$LINENO: checking for $ac_word" >&5
7899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7900 if test "${ac_cv_prog_RANLIB+set}" = set; then
7901   echo $ECHO_N "(cached) $ECHO_C" >&6
7902 else
7903   if test -n "$RANLIB"; then
7904   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7905 else
7906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7907 for as_dir in $PATH
7908 do
7909   IFS=$as_save_IFS
7910   test -z "$as_dir" && as_dir=.
7911   for ac_exec_ext in '' $ac_executable_extensions; do
7912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7913     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7915     break 2
7916   fi
7917 done
7918 done
7919
7920 fi
7921 fi
7922 RANLIB=$ac_cv_prog_RANLIB
7923 if test -n "$RANLIB"; then
7924   echo "$as_me:$LINENO: result: $RANLIB" >&5
7925 echo "${ECHO_T}$RANLIB" >&6
7926 else
7927   echo "$as_me:$LINENO: result: no" >&5
7928 echo "${ECHO_T}no" >&6
7929 fi
7930
7931   fi
7932   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7933     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7934 set dummy ${ncn_progname}; ac_word=$2
7935 echo "$as_me:$LINENO: checking for $ac_word" >&5
7936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7937 if test "${ac_cv_prog_RANLIB+set}" = set; then
7938   echo $ECHO_N "(cached) $ECHO_C" >&6
7939 else
7940   if test -n "$RANLIB"; then
7941   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7942 else
7943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7944 for as_dir in $PATH
7945 do
7946   IFS=$as_save_IFS
7947   test -z "$as_dir" && as_dir=.
7948   for ac_exec_ext in '' $ac_executable_extensions; do
7949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7950     ac_cv_prog_RANLIB="${ncn_progname}"
7951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7952     break 2
7953   fi
7954 done
7955 done
7956
7957 fi
7958 fi
7959 RANLIB=$ac_cv_prog_RANLIB
7960 if test -n "$RANLIB"; then
7961   echo "$as_me:$LINENO: result: $RANLIB" >&5
7962 echo "${ECHO_T}$RANLIB" >&6
7963 else
7964   echo "$as_me:$LINENO: result: no" >&5
7965 echo "${ECHO_T}no" >&6
7966 fi
7967
7968   fi
7969   test -n "$ac_cv_prog_RANLIB" && break
7970 done
7971
7972 if test -z "$ac_cv_prog_RANLIB" ; then
7973   RANLIB=":"
7974 fi
7975
7976
7977
7978 if test -n "$STRIP"; then
7979   ac_cv_prog_STRIP=$STRIP
7980 elif test -n "$ac_cv_prog_STRIP"; then
7981   STRIP=$ac_cv_prog_STRIP
7982 fi
7983
7984 if test -n "$ac_cv_prog_STRIP"; then
7985   for ncn_progname in strip; do
7986     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7987 set dummy ${ncn_progname}; ac_word=$2
7988 echo "$as_me:$LINENO: checking for $ac_word" >&5
7989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7990 if test "${ac_cv_prog_STRIP+set}" = set; then
7991   echo $ECHO_N "(cached) $ECHO_C" >&6
7992 else
7993   if test -n "$STRIP"; then
7994   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7995 else
7996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7997 for as_dir in $PATH
7998 do
7999   IFS=$as_save_IFS
8000   test -z "$as_dir" && as_dir=.
8001   for ac_exec_ext in '' $ac_executable_extensions; do
8002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8003     ac_cv_prog_STRIP="${ncn_progname}"
8004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8005     break 2
8006   fi
8007 done
8008 done
8009
8010 fi
8011 fi
8012 STRIP=$ac_cv_prog_STRIP
8013 if test -n "$STRIP"; then
8014   echo "$as_me:$LINENO: result: $STRIP" >&5
8015 echo "${ECHO_T}$STRIP" >&6
8016 else
8017   echo "$as_me:$LINENO: result: no" >&5
8018 echo "${ECHO_T}no" >&6
8019 fi
8020
8021   done
8022 fi
8023
8024 for ncn_progname in strip; do
8025   if test -n "$ncn_tool_prefix"; then
8026     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8027 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8028 echo "$as_me:$LINENO: checking for $ac_word" >&5
8029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8030 if test "${ac_cv_prog_STRIP+set}" = set; then
8031   echo $ECHO_N "(cached) $ECHO_C" >&6
8032 else
8033   if test -n "$STRIP"; then
8034   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8035 else
8036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8037 for as_dir in $PATH
8038 do
8039   IFS=$as_save_IFS
8040   test -z "$as_dir" && as_dir=.
8041   for ac_exec_ext in '' $ac_executable_extensions; do
8042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8043     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
8044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8045     break 2
8046   fi
8047 done
8048 done
8049
8050 fi
8051 fi
8052 STRIP=$ac_cv_prog_STRIP
8053 if test -n "$STRIP"; then
8054   echo "$as_me:$LINENO: result: $STRIP" >&5
8055 echo "${ECHO_T}$STRIP" >&6
8056 else
8057   echo "$as_me:$LINENO: result: no" >&5
8058 echo "${ECHO_T}no" >&6
8059 fi
8060
8061   fi
8062   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
8063     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8064 set dummy ${ncn_progname}; ac_word=$2
8065 echo "$as_me:$LINENO: checking for $ac_word" >&5
8066 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8067 if test "${ac_cv_prog_STRIP+set}" = set; then
8068   echo $ECHO_N "(cached) $ECHO_C" >&6
8069 else
8070   if test -n "$STRIP"; then
8071   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
8072 else
8073 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8074 for as_dir in $PATH
8075 do
8076   IFS=$as_save_IFS
8077   test -z "$as_dir" && as_dir=.
8078   for ac_exec_ext in '' $ac_executable_extensions; do
8079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8080     ac_cv_prog_STRIP="${ncn_progname}"
8081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8082     break 2
8083   fi
8084 done
8085 done
8086
8087 fi
8088 fi
8089 STRIP=$ac_cv_prog_STRIP
8090 if test -n "$STRIP"; then
8091   echo "$as_me:$LINENO: result: $STRIP" >&5
8092 echo "${ECHO_T}$STRIP" >&6
8093 else
8094   echo "$as_me:$LINENO: result: no" >&5
8095 echo "${ECHO_T}no" >&6
8096 fi
8097
8098   fi
8099   test -n "$ac_cv_prog_STRIP" && break
8100 done
8101
8102 if test -z "$ac_cv_prog_STRIP" ; then
8103   STRIP=":"
8104 fi
8105
8106
8107
8108 if test -n "$WINDRES"; then
8109   ac_cv_prog_WINDRES=$WINDRES
8110 elif test -n "$ac_cv_prog_WINDRES"; then
8111   WINDRES=$ac_cv_prog_WINDRES
8112 fi
8113
8114 if test -n "$ac_cv_prog_WINDRES"; then
8115   for ncn_progname in windres; do
8116     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8117 set dummy ${ncn_progname}; ac_word=$2
8118 echo "$as_me:$LINENO: checking for $ac_word" >&5
8119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8120 if test "${ac_cv_prog_WINDRES+set}" = set; then
8121   echo $ECHO_N "(cached) $ECHO_C" >&6
8122 else
8123   if test -n "$WINDRES"; then
8124   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8125 else
8126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8127 for as_dir in $PATH
8128 do
8129   IFS=$as_save_IFS
8130   test -z "$as_dir" && as_dir=.
8131   for ac_exec_ext in '' $ac_executable_extensions; do
8132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8133     ac_cv_prog_WINDRES="${ncn_progname}"
8134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8135     break 2
8136   fi
8137 done
8138 done
8139
8140 fi
8141 fi
8142 WINDRES=$ac_cv_prog_WINDRES
8143 if test -n "$WINDRES"; then
8144   echo "$as_me:$LINENO: result: $WINDRES" >&5
8145 echo "${ECHO_T}$WINDRES" >&6
8146 else
8147   echo "$as_me:$LINENO: result: no" >&5
8148 echo "${ECHO_T}no" >&6
8149 fi
8150
8151   done
8152 fi
8153
8154 for ncn_progname in windres; do
8155   if test -n "$ncn_tool_prefix"; then
8156     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8157 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8158 echo "$as_me:$LINENO: checking for $ac_word" >&5
8159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8160 if test "${ac_cv_prog_WINDRES+set}" = set; then
8161   echo $ECHO_N "(cached) $ECHO_C" >&6
8162 else
8163   if test -n "$WINDRES"; then
8164   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8165 else
8166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8167 for as_dir in $PATH
8168 do
8169   IFS=$as_save_IFS
8170   test -z "$as_dir" && as_dir=.
8171   for ac_exec_ext in '' $ac_executable_extensions; do
8172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8173     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
8174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8175     break 2
8176   fi
8177 done
8178 done
8179
8180 fi
8181 fi
8182 WINDRES=$ac_cv_prog_WINDRES
8183 if test -n "$WINDRES"; then
8184   echo "$as_me:$LINENO: result: $WINDRES" >&5
8185 echo "${ECHO_T}$WINDRES" >&6
8186 else
8187   echo "$as_me:$LINENO: result: no" >&5
8188 echo "${ECHO_T}no" >&6
8189 fi
8190
8191   fi
8192   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
8193     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8194 set dummy ${ncn_progname}; ac_word=$2
8195 echo "$as_me:$LINENO: checking for $ac_word" >&5
8196 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8197 if test "${ac_cv_prog_WINDRES+set}" = set; then
8198   echo $ECHO_N "(cached) $ECHO_C" >&6
8199 else
8200   if test -n "$WINDRES"; then
8201   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
8202 else
8203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8204 for as_dir in $PATH
8205 do
8206   IFS=$as_save_IFS
8207   test -z "$as_dir" && as_dir=.
8208   for ac_exec_ext in '' $ac_executable_extensions; do
8209   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8210     ac_cv_prog_WINDRES="${ncn_progname}"
8211     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8212     break 2
8213   fi
8214 done
8215 done
8216
8217 fi
8218 fi
8219 WINDRES=$ac_cv_prog_WINDRES
8220 if test -n "$WINDRES"; then
8221   echo "$as_me:$LINENO: result: $WINDRES" >&5
8222 echo "${ECHO_T}$WINDRES" >&6
8223 else
8224   echo "$as_me:$LINENO: result: no" >&5
8225 echo "${ECHO_T}no" >&6
8226 fi
8227
8228   fi
8229   test -n "$ac_cv_prog_WINDRES" && break
8230 done
8231
8232 if test -z "$ac_cv_prog_WINDRES" ; then
8233   set dummy windres
8234   if test $build = $host ; then
8235     WINDRES="$2"
8236   else
8237     WINDRES="${ncn_tool_prefix}$2"
8238   fi
8239 fi
8240
8241
8242
8243 if test -n "$WINDMC"; then
8244   ac_cv_prog_WINDMC=$WINDMC
8245 elif test -n "$ac_cv_prog_WINDMC"; then
8246   WINDMC=$ac_cv_prog_WINDMC
8247 fi
8248
8249 if test -n "$ac_cv_prog_WINDMC"; then
8250   for ncn_progname in windmc; do
8251     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8252 set dummy ${ncn_progname}; ac_word=$2
8253 echo "$as_me:$LINENO: checking for $ac_word" >&5
8254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8255 if test "${ac_cv_prog_WINDMC+set}" = set; then
8256   echo $ECHO_N "(cached) $ECHO_C" >&6
8257 else
8258   if test -n "$WINDMC"; then
8259   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8260 else
8261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8262 for as_dir in $PATH
8263 do
8264   IFS=$as_save_IFS
8265   test -z "$as_dir" && as_dir=.
8266   for ac_exec_ext in '' $ac_executable_extensions; do
8267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8268     ac_cv_prog_WINDMC="${ncn_progname}"
8269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8270     break 2
8271   fi
8272 done
8273 done
8274
8275 fi
8276 fi
8277 WINDMC=$ac_cv_prog_WINDMC
8278 if test -n "$WINDMC"; then
8279   echo "$as_me:$LINENO: result: $WINDMC" >&5
8280 echo "${ECHO_T}$WINDMC" >&6
8281 else
8282   echo "$as_me:$LINENO: result: no" >&5
8283 echo "${ECHO_T}no" >&6
8284 fi
8285
8286   done
8287 fi
8288
8289 for ncn_progname in windmc; do
8290   if test -n "$ncn_tool_prefix"; then
8291     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8292 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8293 echo "$as_me:$LINENO: checking for $ac_word" >&5
8294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8295 if test "${ac_cv_prog_WINDMC+set}" = set; then
8296   echo $ECHO_N "(cached) $ECHO_C" >&6
8297 else
8298   if test -n "$WINDMC"; then
8299   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8300 else
8301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8302 for as_dir in $PATH
8303 do
8304   IFS=$as_save_IFS
8305   test -z "$as_dir" && as_dir=.
8306   for ac_exec_ext in '' $ac_executable_extensions; do
8307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8308     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8310     break 2
8311   fi
8312 done
8313 done
8314
8315 fi
8316 fi
8317 WINDMC=$ac_cv_prog_WINDMC
8318 if test -n "$WINDMC"; then
8319   echo "$as_me:$LINENO: result: $WINDMC" >&5
8320 echo "${ECHO_T}$WINDMC" >&6
8321 else
8322   echo "$as_me:$LINENO: result: no" >&5
8323 echo "${ECHO_T}no" >&6
8324 fi
8325
8326   fi
8327   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8328     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8329 set dummy ${ncn_progname}; ac_word=$2
8330 echo "$as_me:$LINENO: checking for $ac_word" >&5
8331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8332 if test "${ac_cv_prog_WINDMC+set}" = set; then
8333   echo $ECHO_N "(cached) $ECHO_C" >&6
8334 else
8335   if test -n "$WINDMC"; then
8336   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8337 else
8338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8339 for as_dir in $PATH
8340 do
8341   IFS=$as_save_IFS
8342   test -z "$as_dir" && as_dir=.
8343   for ac_exec_ext in '' $ac_executable_extensions; do
8344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8345     ac_cv_prog_WINDMC="${ncn_progname}"
8346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8347     break 2
8348   fi
8349 done
8350 done
8351
8352 fi
8353 fi
8354 WINDMC=$ac_cv_prog_WINDMC
8355 if test -n "$WINDMC"; then
8356   echo "$as_me:$LINENO: result: $WINDMC" >&5
8357 echo "${ECHO_T}$WINDMC" >&6
8358 else
8359   echo "$as_me:$LINENO: result: no" >&5
8360 echo "${ECHO_T}no" >&6
8361 fi
8362
8363   fi
8364   test -n "$ac_cv_prog_WINDMC" && break
8365 done
8366
8367 if test -z "$ac_cv_prog_WINDMC" ; then
8368   set dummy windmc
8369   if test $build = $host ; then
8370     WINDMC="$2"
8371   else
8372     WINDMC="${ncn_tool_prefix}$2"
8373   fi
8374 fi
8375
8376
8377
8378 if test -n "$OBJCOPY"; then
8379   ac_cv_prog_OBJCOPY=$OBJCOPY
8380 elif test -n "$ac_cv_prog_OBJCOPY"; then
8381   OBJCOPY=$ac_cv_prog_OBJCOPY
8382 fi
8383
8384 if test -n "$ac_cv_prog_OBJCOPY"; then
8385   for ncn_progname in objcopy; do
8386     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8387 set dummy ${ncn_progname}; ac_word=$2
8388 echo "$as_me:$LINENO: checking for $ac_word" >&5
8389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8390 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8391   echo $ECHO_N "(cached) $ECHO_C" >&6
8392 else
8393   if test -n "$OBJCOPY"; then
8394   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8395 else
8396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8397 for as_dir in $PATH
8398 do
8399   IFS=$as_save_IFS
8400   test -z "$as_dir" && as_dir=.
8401   for ac_exec_ext in '' $ac_executable_extensions; do
8402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8403     ac_cv_prog_OBJCOPY="${ncn_progname}"
8404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8405     break 2
8406   fi
8407 done
8408 done
8409
8410 fi
8411 fi
8412 OBJCOPY=$ac_cv_prog_OBJCOPY
8413 if test -n "$OBJCOPY"; then
8414   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8415 echo "${ECHO_T}$OBJCOPY" >&6
8416 else
8417   echo "$as_me:$LINENO: result: no" >&5
8418 echo "${ECHO_T}no" >&6
8419 fi
8420
8421   done
8422 fi
8423
8424 for ncn_progname in objcopy; do
8425   if test -n "$ncn_tool_prefix"; then
8426     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8427 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8428 echo "$as_me:$LINENO: checking for $ac_word" >&5
8429 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8430 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8431   echo $ECHO_N "(cached) $ECHO_C" >&6
8432 else
8433   if test -n "$OBJCOPY"; then
8434   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8435 else
8436 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8437 for as_dir in $PATH
8438 do
8439   IFS=$as_save_IFS
8440   test -z "$as_dir" && as_dir=.
8441   for ac_exec_ext in '' $ac_executable_extensions; do
8442   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8443     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8444     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8445     break 2
8446   fi
8447 done
8448 done
8449
8450 fi
8451 fi
8452 OBJCOPY=$ac_cv_prog_OBJCOPY
8453 if test -n "$OBJCOPY"; then
8454   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8455 echo "${ECHO_T}$OBJCOPY" >&6
8456 else
8457   echo "$as_me:$LINENO: result: no" >&5
8458 echo "${ECHO_T}no" >&6
8459 fi
8460
8461   fi
8462   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8463     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8464 set dummy ${ncn_progname}; ac_word=$2
8465 echo "$as_me:$LINENO: checking for $ac_word" >&5
8466 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8467 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8468   echo $ECHO_N "(cached) $ECHO_C" >&6
8469 else
8470   if test -n "$OBJCOPY"; then
8471   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8472 else
8473 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8474 for as_dir in $PATH
8475 do
8476   IFS=$as_save_IFS
8477   test -z "$as_dir" && as_dir=.
8478   for ac_exec_ext in '' $ac_executable_extensions; do
8479   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8480     ac_cv_prog_OBJCOPY="${ncn_progname}"
8481     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8482     break 2
8483   fi
8484 done
8485 done
8486
8487 fi
8488 fi
8489 OBJCOPY=$ac_cv_prog_OBJCOPY
8490 if test -n "$OBJCOPY"; then
8491   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8492 echo "${ECHO_T}$OBJCOPY" >&6
8493 else
8494   echo "$as_me:$LINENO: result: no" >&5
8495 echo "${ECHO_T}no" >&6
8496 fi
8497
8498   fi
8499   test -n "$ac_cv_prog_OBJCOPY" && break
8500 done
8501
8502 if test -z "$ac_cv_prog_OBJCOPY" ; then
8503   set dummy objcopy
8504   if test $build = $host ; then
8505     OBJCOPY="$2"
8506   else
8507     OBJCOPY="${ncn_tool_prefix}$2"
8508   fi
8509 fi
8510
8511
8512
8513 if test -n "$OBJDUMP"; then
8514   ac_cv_prog_OBJDUMP=$OBJDUMP
8515 elif test -n "$ac_cv_prog_OBJDUMP"; then
8516   OBJDUMP=$ac_cv_prog_OBJDUMP
8517 fi
8518
8519 if test -n "$ac_cv_prog_OBJDUMP"; then
8520   for ncn_progname in objdump; do
8521     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8522 set dummy ${ncn_progname}; ac_word=$2
8523 echo "$as_me:$LINENO: checking for $ac_word" >&5
8524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8525 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8526   echo $ECHO_N "(cached) $ECHO_C" >&6
8527 else
8528   if test -n "$OBJDUMP"; then
8529   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8530 else
8531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8532 for as_dir in $PATH
8533 do
8534   IFS=$as_save_IFS
8535   test -z "$as_dir" && as_dir=.
8536   for ac_exec_ext in '' $ac_executable_extensions; do
8537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8538     ac_cv_prog_OBJDUMP="${ncn_progname}"
8539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8540     break 2
8541   fi
8542 done
8543 done
8544
8545 fi
8546 fi
8547 OBJDUMP=$ac_cv_prog_OBJDUMP
8548 if test -n "$OBJDUMP"; then
8549   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8550 echo "${ECHO_T}$OBJDUMP" >&6
8551 else
8552   echo "$as_me:$LINENO: result: no" >&5
8553 echo "${ECHO_T}no" >&6
8554 fi
8555
8556   done
8557 fi
8558
8559 for ncn_progname in objdump; do
8560   if test -n "$ncn_tool_prefix"; then
8561     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8562 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8563 echo "$as_me:$LINENO: checking for $ac_word" >&5
8564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8565 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8566   echo $ECHO_N "(cached) $ECHO_C" >&6
8567 else
8568   if test -n "$OBJDUMP"; then
8569   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8570 else
8571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8572 for as_dir in $PATH
8573 do
8574   IFS=$as_save_IFS
8575   test -z "$as_dir" && as_dir=.
8576   for ac_exec_ext in '' $ac_executable_extensions; do
8577   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8578     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8579     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8580     break 2
8581   fi
8582 done
8583 done
8584
8585 fi
8586 fi
8587 OBJDUMP=$ac_cv_prog_OBJDUMP
8588 if test -n "$OBJDUMP"; then
8589   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8590 echo "${ECHO_T}$OBJDUMP" >&6
8591 else
8592   echo "$as_me:$LINENO: result: no" >&5
8593 echo "${ECHO_T}no" >&6
8594 fi
8595
8596   fi
8597   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8598     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8599 set dummy ${ncn_progname}; ac_word=$2
8600 echo "$as_me:$LINENO: checking for $ac_word" >&5
8601 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8602 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8603   echo $ECHO_N "(cached) $ECHO_C" >&6
8604 else
8605   if test -n "$OBJDUMP"; then
8606   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8607 else
8608 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8609 for as_dir in $PATH
8610 do
8611   IFS=$as_save_IFS
8612   test -z "$as_dir" && as_dir=.
8613   for ac_exec_ext in '' $ac_executable_extensions; do
8614   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8615     ac_cv_prog_OBJDUMP="${ncn_progname}"
8616     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8617     break 2
8618   fi
8619 done
8620 done
8621
8622 fi
8623 fi
8624 OBJDUMP=$ac_cv_prog_OBJDUMP
8625 if test -n "$OBJDUMP"; then
8626   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8627 echo "${ECHO_T}$OBJDUMP" >&6
8628 else
8629   echo "$as_me:$LINENO: result: no" >&5
8630 echo "${ECHO_T}no" >&6
8631 fi
8632
8633   fi
8634   test -n "$ac_cv_prog_OBJDUMP" && break
8635 done
8636
8637 if test -z "$ac_cv_prog_OBJDUMP" ; then
8638   set dummy objdump
8639   if test $build = $host ; then
8640     OBJDUMP="$2"
8641   else
8642     OBJDUMP="${ncn_tool_prefix}$2"
8643   fi
8644 fi
8645
8646
8647
8648
8649
8650
8651 # Target tools.
8652
8653 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8654 if test "${with_build_time_tools+set}" = set; then
8655   withval="$with_build_time_tools"
8656   case x"$withval" in
8657      x/*) ;;
8658      *)
8659        with_build_time_tools=
8660        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8661 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8662        ;;
8663    esac
8664 else
8665   with_build_time_tools=
8666 fi;
8667
8668
8669
8670 if test -n "$CC_FOR_TARGET"; then
8671   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8672 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8673   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8674 fi
8675
8676 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8677   for ncn_progname in cc gcc; do
8678     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8679 set dummy ${ncn_progname}; ac_word=$2
8680 echo "$as_me:$LINENO: checking for $ac_word" >&5
8681 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8682 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8683   echo $ECHO_N "(cached) $ECHO_C" >&6
8684 else
8685   if test -n "$CC_FOR_TARGET"; then
8686   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8687 else
8688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8689 for as_dir in $PATH
8690 do
8691   IFS=$as_save_IFS
8692   test -z "$as_dir" && as_dir=.
8693   for ac_exec_ext in '' $ac_executable_extensions; do
8694   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8695     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8696     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8697     break 2
8698   fi
8699 done
8700 done
8701
8702 fi
8703 fi
8704 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8705 if test -n "$CC_FOR_TARGET"; then
8706   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8707 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8708 else
8709   echo "$as_me:$LINENO: result: no" >&5
8710 echo "${ECHO_T}no" >&6
8711 fi
8712
8713   done
8714 fi
8715
8716 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8717   for ncn_progname in cc gcc; do
8718     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8719 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8720     if test -x $with_build_time_tools/${ncn_progname}; then
8721       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8722       echo "$as_me:$LINENO: result: yes" >&5
8723 echo "${ECHO_T}yes" >&6
8724       break
8725     else
8726       echo "$as_me:$LINENO: result: no" >&5
8727 echo "${ECHO_T}no" >&6
8728     fi
8729   done
8730 fi
8731
8732 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8733   for ncn_progname in cc gcc; do
8734     if test -n "$ncn_target_tool_prefix"; then
8735       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8736 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8737 echo "$as_me:$LINENO: checking for $ac_word" >&5
8738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8739 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8740   echo $ECHO_N "(cached) $ECHO_C" >&6
8741 else
8742   if test -n "$CC_FOR_TARGET"; then
8743   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8744 else
8745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8746 for as_dir in $PATH
8747 do
8748   IFS=$as_save_IFS
8749   test -z "$as_dir" && as_dir=.
8750   for ac_exec_ext in '' $ac_executable_extensions; do
8751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8752     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8754     break 2
8755   fi
8756 done
8757 done
8758
8759 fi
8760 fi
8761 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8762 if test -n "$CC_FOR_TARGET"; then
8763   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8764 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8765 else
8766   echo "$as_me:$LINENO: result: no" >&5
8767 echo "${ECHO_T}no" >&6
8768 fi
8769
8770     fi
8771     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8772       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8773 set dummy ${ncn_progname}; ac_word=$2
8774 echo "$as_me:$LINENO: checking for $ac_word" >&5
8775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8776 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8777   echo $ECHO_N "(cached) $ECHO_C" >&6
8778 else
8779   if test -n "$CC_FOR_TARGET"; then
8780   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8781 else
8782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8783 for as_dir in $PATH
8784 do
8785   IFS=$as_save_IFS
8786   test -z "$as_dir" && as_dir=.
8787   for ac_exec_ext in '' $ac_executable_extensions; do
8788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8789     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8791     break 2
8792   fi
8793 done
8794 done
8795
8796 fi
8797 fi
8798 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8799 if test -n "$CC_FOR_TARGET"; then
8800   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8801 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8802 else
8803   echo "$as_me:$LINENO: result: no" >&5
8804 echo "${ECHO_T}no" >&6
8805 fi
8806
8807     fi
8808     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8809   done
8810 fi
8811
8812 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8813   set dummy cc gcc
8814   if test $build = $target ; then
8815     CC_FOR_TARGET="$2"
8816   else
8817     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8818   fi
8819 else
8820   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8821 fi
8822
8823
8824
8825 if test -n "$CXX_FOR_TARGET"; then
8826   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8827 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8828   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8829 fi
8830
8831 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8832   for ncn_progname in c++ g++ cxx gxx; do
8833     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8834 set dummy ${ncn_progname}; ac_word=$2
8835 echo "$as_me:$LINENO: checking for $ac_word" >&5
8836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8837 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8838   echo $ECHO_N "(cached) $ECHO_C" >&6
8839 else
8840   if test -n "$CXX_FOR_TARGET"; then
8841   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8842 else
8843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8844 for as_dir in $PATH
8845 do
8846   IFS=$as_save_IFS
8847   test -z "$as_dir" && as_dir=.
8848   for ac_exec_ext in '' $ac_executable_extensions; do
8849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8850     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8852     break 2
8853   fi
8854 done
8855 done
8856
8857 fi
8858 fi
8859 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8860 if test -n "$CXX_FOR_TARGET"; then
8861   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8862 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8863 else
8864   echo "$as_me:$LINENO: result: no" >&5
8865 echo "${ECHO_T}no" >&6
8866 fi
8867
8868   done
8869 fi
8870
8871 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8872   for ncn_progname in c++ g++ cxx gxx; do
8873     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8874 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8875     if test -x $with_build_time_tools/${ncn_progname}; then
8876       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8877       echo "$as_me:$LINENO: result: yes" >&5
8878 echo "${ECHO_T}yes" >&6
8879       break
8880     else
8881       echo "$as_me:$LINENO: result: no" >&5
8882 echo "${ECHO_T}no" >&6
8883     fi
8884   done
8885 fi
8886
8887 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8888   for ncn_progname in c++ g++ cxx gxx; do
8889     if test -n "$ncn_target_tool_prefix"; then
8890       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8891 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8892 echo "$as_me:$LINENO: checking for $ac_word" >&5
8893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8894 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8895   echo $ECHO_N "(cached) $ECHO_C" >&6
8896 else
8897   if test -n "$CXX_FOR_TARGET"; then
8898   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8899 else
8900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8901 for as_dir in $PATH
8902 do
8903   IFS=$as_save_IFS
8904   test -z "$as_dir" && as_dir=.
8905   for ac_exec_ext in '' $ac_executable_extensions; do
8906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8907     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8909     break 2
8910   fi
8911 done
8912 done
8913
8914 fi
8915 fi
8916 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8917 if test -n "$CXX_FOR_TARGET"; then
8918   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8919 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8920 else
8921   echo "$as_me:$LINENO: result: no" >&5
8922 echo "${ECHO_T}no" >&6
8923 fi
8924
8925     fi
8926     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8927       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8928 set dummy ${ncn_progname}; ac_word=$2
8929 echo "$as_me:$LINENO: checking for $ac_word" >&5
8930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8931 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8932   echo $ECHO_N "(cached) $ECHO_C" >&6
8933 else
8934   if test -n "$CXX_FOR_TARGET"; then
8935   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8936 else
8937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8938 for as_dir in $PATH
8939 do
8940   IFS=$as_save_IFS
8941   test -z "$as_dir" && as_dir=.
8942   for ac_exec_ext in '' $ac_executable_extensions; do
8943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8944     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8946     break 2
8947   fi
8948 done
8949 done
8950
8951 fi
8952 fi
8953 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8954 if test -n "$CXX_FOR_TARGET"; then
8955   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8956 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8957 else
8958   echo "$as_me:$LINENO: result: no" >&5
8959 echo "${ECHO_T}no" >&6
8960 fi
8961
8962     fi
8963     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8964   done
8965 fi
8966
8967 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8968   set dummy c++ g++ cxx gxx
8969   if test $build = $target ; then
8970     CXX_FOR_TARGET="$2"
8971   else
8972     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8973   fi
8974 else
8975   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8976 fi
8977
8978
8979
8980 if test -n "$GCC_FOR_TARGET"; then
8981   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8982 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8983   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8984 fi
8985
8986 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8987   for ncn_progname in gcc; do
8988     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8989 set dummy ${ncn_progname}; ac_word=$2
8990 echo "$as_me:$LINENO: checking for $ac_word" >&5
8991 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8992 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8993   echo $ECHO_N "(cached) $ECHO_C" >&6
8994 else
8995   if test -n "$GCC_FOR_TARGET"; then
8996   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8997 else
8998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8999 for as_dir in $PATH
9000 do
9001   IFS=$as_save_IFS
9002   test -z "$as_dir" && as_dir=.
9003   for ac_exec_ext in '' $ac_executable_extensions; do
9004   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9005     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9006     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9007     break 2
9008   fi
9009 done
9010 done
9011
9012 fi
9013 fi
9014 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9015 if test -n "$GCC_FOR_TARGET"; then
9016   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9017 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9018 else
9019   echo "$as_me:$LINENO: result: no" >&5
9020 echo "${ECHO_T}no" >&6
9021 fi
9022
9023   done
9024 fi
9025
9026 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
9027   for ncn_progname in gcc; do
9028     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9029 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9030     if test -x $with_build_time_tools/${ncn_progname}; then
9031       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9032       echo "$as_me:$LINENO: result: yes" >&5
9033 echo "${ECHO_T}yes" >&6
9034       break
9035     else
9036       echo "$as_me:$LINENO: result: no" >&5
9037 echo "${ECHO_T}no" >&6
9038     fi
9039   done
9040 fi
9041
9042 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
9043   for ncn_progname in gcc; do
9044     if test -n "$ncn_target_tool_prefix"; then
9045       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9046 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9047 echo "$as_me:$LINENO: checking for $ac_word" >&5
9048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9049 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9050   echo $ECHO_N "(cached) $ECHO_C" >&6
9051 else
9052   if test -n "$GCC_FOR_TARGET"; then
9053   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9054 else
9055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9056 for as_dir in $PATH
9057 do
9058   IFS=$as_save_IFS
9059   test -z "$as_dir" && as_dir=.
9060   for ac_exec_ext in '' $ac_executable_extensions; do
9061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9062     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9064     break 2
9065   fi
9066 done
9067 done
9068
9069 fi
9070 fi
9071 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9072 if test -n "$GCC_FOR_TARGET"; then
9073   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9074 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9075 else
9076   echo "$as_me:$LINENO: result: no" >&5
9077 echo "${ECHO_T}no" >&6
9078 fi
9079
9080     fi
9081     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
9082       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9083 set dummy ${ncn_progname}; ac_word=$2
9084 echo "$as_me:$LINENO: checking for $ac_word" >&5
9085 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9086 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
9087   echo $ECHO_N "(cached) $ECHO_C" >&6
9088 else
9089   if test -n "$GCC_FOR_TARGET"; then
9090   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
9091 else
9092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9093 for as_dir in $PATH
9094 do
9095   IFS=$as_save_IFS
9096   test -z "$as_dir" && as_dir=.
9097   for ac_exec_ext in '' $ac_executable_extensions; do
9098   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9099     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
9100     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9101     break 2
9102   fi
9103 done
9104 done
9105
9106 fi
9107 fi
9108 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
9109 if test -n "$GCC_FOR_TARGET"; then
9110   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
9111 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
9112 else
9113   echo "$as_me:$LINENO: result: no" >&5
9114 echo "${ECHO_T}no" >&6
9115 fi
9116
9117     fi
9118     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
9119   done
9120 fi
9121
9122 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
9123   GCC_FOR_TARGET="${CC_FOR_TARGET}"
9124 else
9125   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
9126 fi
9127
9128
9129
9130 if test -n "$GCJ_FOR_TARGET"; then
9131   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
9132 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9133   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9134 fi
9135
9136 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
9137   for ncn_progname in gcj; do
9138     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9139 set dummy ${ncn_progname}; ac_word=$2
9140 echo "$as_me:$LINENO: checking for $ac_word" >&5
9141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9142 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9143   echo $ECHO_N "(cached) $ECHO_C" >&6
9144 else
9145   if test -n "$GCJ_FOR_TARGET"; then
9146   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9147 else
9148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9149 for as_dir in $PATH
9150 do
9151   IFS=$as_save_IFS
9152   test -z "$as_dir" && as_dir=.
9153   for ac_exec_ext in '' $ac_executable_extensions; do
9154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9155     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9157     break 2
9158   fi
9159 done
9160 done
9161
9162 fi
9163 fi
9164 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9165 if test -n "$GCJ_FOR_TARGET"; then
9166   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9167 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9168 else
9169   echo "$as_me:$LINENO: result: no" >&5
9170 echo "${ECHO_T}no" >&6
9171 fi
9172
9173   done
9174 fi
9175
9176 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
9177   for ncn_progname in gcj; do
9178     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9179 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9180     if test -x $with_build_time_tools/${ncn_progname}; then
9181       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9182       echo "$as_me:$LINENO: result: yes" >&5
9183 echo "${ECHO_T}yes" >&6
9184       break
9185     else
9186       echo "$as_me:$LINENO: result: no" >&5
9187 echo "${ECHO_T}no" >&6
9188     fi
9189   done
9190 fi
9191
9192 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
9193   for ncn_progname in gcj; do
9194     if test -n "$ncn_target_tool_prefix"; then
9195       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9196 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9197 echo "$as_me:$LINENO: checking for $ac_word" >&5
9198 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9199 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9200   echo $ECHO_N "(cached) $ECHO_C" >&6
9201 else
9202   if test -n "$GCJ_FOR_TARGET"; then
9203   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9204 else
9205 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9206 for as_dir in $PATH
9207 do
9208   IFS=$as_save_IFS
9209   test -z "$as_dir" && as_dir=.
9210   for ac_exec_ext in '' $ac_executable_extensions; do
9211   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9212     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9213     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9214     break 2
9215   fi
9216 done
9217 done
9218
9219 fi
9220 fi
9221 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9222 if test -n "$GCJ_FOR_TARGET"; then
9223   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9224 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9225 else
9226   echo "$as_me:$LINENO: result: no" >&5
9227 echo "${ECHO_T}no" >&6
9228 fi
9229
9230     fi
9231     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
9232       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9233 set dummy ${ncn_progname}; ac_word=$2
9234 echo "$as_me:$LINENO: checking for $ac_word" >&5
9235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9236 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
9237   echo $ECHO_N "(cached) $ECHO_C" >&6
9238 else
9239   if test -n "$GCJ_FOR_TARGET"; then
9240   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
9241 else
9242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9243 for as_dir in $PATH
9244 do
9245   IFS=$as_save_IFS
9246   test -z "$as_dir" && as_dir=.
9247   for ac_exec_ext in '' $ac_executable_extensions; do
9248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9249     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9251     break 2
9252   fi
9253 done
9254 done
9255
9256 fi
9257 fi
9258 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9259 if test -n "$GCJ_FOR_TARGET"; then
9260   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9261 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9262 else
9263   echo "$as_me:$LINENO: result: no" >&5
9264 echo "${ECHO_T}no" >&6
9265 fi
9266
9267     fi
9268     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9269   done
9270 fi
9271
9272 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9273   set dummy gcj
9274   if test $build = $target ; then
9275     GCJ_FOR_TARGET="$2"
9276   else
9277     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9278   fi
9279 else
9280   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9281 fi
9282
9283
9284
9285 if test -n "$GFORTRAN_FOR_TARGET"; then
9286   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9287 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9288   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9289 fi
9290
9291 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9292   for ncn_progname in gfortran; do
9293     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9294 set dummy ${ncn_progname}; ac_word=$2
9295 echo "$as_me:$LINENO: checking for $ac_word" >&5
9296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9297 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9298   echo $ECHO_N "(cached) $ECHO_C" >&6
9299 else
9300   if test -n "$GFORTRAN_FOR_TARGET"; then
9301   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9302 else
9303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9304 for as_dir in $PATH
9305 do
9306   IFS=$as_save_IFS
9307   test -z "$as_dir" && as_dir=.
9308   for ac_exec_ext in '' $ac_executable_extensions; do
9309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9310     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9312     break 2
9313   fi
9314 done
9315 done
9316
9317 fi
9318 fi
9319 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9320 if test -n "$GFORTRAN_FOR_TARGET"; then
9321   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9322 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9323 else
9324   echo "$as_me:$LINENO: result: no" >&5
9325 echo "${ECHO_T}no" >&6
9326 fi
9327
9328   done
9329 fi
9330
9331 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9332   for ncn_progname in gfortran; do
9333     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9334 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9335     if test -x $with_build_time_tools/${ncn_progname}; then
9336       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9337       echo "$as_me:$LINENO: result: yes" >&5
9338 echo "${ECHO_T}yes" >&6
9339       break
9340     else
9341       echo "$as_me:$LINENO: result: no" >&5
9342 echo "${ECHO_T}no" >&6
9343     fi
9344   done
9345 fi
9346
9347 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9348   for ncn_progname in gfortran; do
9349     if test -n "$ncn_target_tool_prefix"; then
9350       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9351 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9352 echo "$as_me:$LINENO: checking for $ac_word" >&5
9353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9354 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9355   echo $ECHO_N "(cached) $ECHO_C" >&6
9356 else
9357   if test -n "$GFORTRAN_FOR_TARGET"; then
9358   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9359 else
9360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9361 for as_dir in $PATH
9362 do
9363   IFS=$as_save_IFS
9364   test -z "$as_dir" && as_dir=.
9365   for ac_exec_ext in '' $ac_executable_extensions; do
9366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9367     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9369     break 2
9370   fi
9371 done
9372 done
9373
9374 fi
9375 fi
9376 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9377 if test -n "$GFORTRAN_FOR_TARGET"; then
9378   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9379 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9380 else
9381   echo "$as_me:$LINENO: result: no" >&5
9382 echo "${ECHO_T}no" >&6
9383 fi
9384
9385     fi
9386     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9387       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9388 set dummy ${ncn_progname}; ac_word=$2
9389 echo "$as_me:$LINENO: checking for $ac_word" >&5
9390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9391 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9392   echo $ECHO_N "(cached) $ECHO_C" >&6
9393 else
9394   if test -n "$GFORTRAN_FOR_TARGET"; then
9395   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9396 else
9397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9398 for as_dir in $PATH
9399 do
9400   IFS=$as_save_IFS
9401   test -z "$as_dir" && as_dir=.
9402   for ac_exec_ext in '' $ac_executable_extensions; do
9403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9404     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9406     break 2
9407   fi
9408 done
9409 done
9410
9411 fi
9412 fi
9413 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9414 if test -n "$GFORTRAN_FOR_TARGET"; then
9415   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9416 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9417 else
9418   echo "$as_me:$LINENO: result: no" >&5
9419 echo "${ECHO_T}no" >&6
9420 fi
9421
9422     fi
9423     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9424   done
9425 fi
9426
9427 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9428   set dummy gfortran
9429   if test $build = $target ; then
9430     GFORTRAN_FOR_TARGET="$2"
9431   else
9432     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9433   fi
9434 else
9435   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9436 fi
9437
9438
9439
9440 cat > conftest.c << \EOF
9441 #ifdef __GNUC__
9442   gcc_yay;
9443 #endif
9444 EOF
9445 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9446   have_gcc_for_target=yes
9447 else
9448   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9449   have_gcc_for_target=no
9450 fi
9451 rm conftest.c
9452
9453
9454
9455
9456 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9457   if test -n "$with_build_time_tools"; then
9458     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9459 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9460     if test -x $with_build_time_tools/ar; then
9461       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9462       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9463       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9464 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9465     else
9466       echo "$as_me:$LINENO: result: no" >&5
9467 echo "${ECHO_T}no" >&6
9468     fi
9469   elif test $build != $host && test $have_gcc_for_target = yes; then
9470     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9471     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9472     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9473   fi
9474 fi
9475 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9476   # Extract the first word of "ar", so it can be a program name with args.
9477 set dummy ar; ac_word=$2
9478 echo "$as_me:$LINENO: checking for $ac_word" >&5
9479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9480 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9481   echo $ECHO_N "(cached) $ECHO_C" >&6
9482 else
9483   case $AR_FOR_TARGET in
9484   [\\/]* | ?:[\\/]*)
9485   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9486   ;;
9487   *)
9488   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9489 for as_dir in $gcc_cv_tool_dirs
9490 do
9491   IFS=$as_save_IFS
9492   test -z "$as_dir" && as_dir=.
9493   for ac_exec_ext in '' $ac_executable_extensions; do
9494   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9495     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9496     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9497     break 2
9498   fi
9499 done
9500 done
9501
9502   ;;
9503 esac
9504 fi
9505 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9506
9507 if test -n "$AR_FOR_TARGET"; then
9508   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9509 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9510 else
9511   echo "$as_me:$LINENO: result: no" >&5
9512 echo "${ECHO_T}no" >&6
9513 fi
9514
9515 fi
9516 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9517
9518
9519 if test -n "$AR_FOR_TARGET"; then
9520   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9521 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9522   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9523 fi
9524
9525 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9526   for ncn_progname in ar; do
9527     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9528 set dummy ${ncn_progname}; ac_word=$2
9529 echo "$as_me:$LINENO: checking for $ac_word" >&5
9530 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9531 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9532   echo $ECHO_N "(cached) $ECHO_C" >&6
9533 else
9534   if test -n "$AR_FOR_TARGET"; then
9535   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9536 else
9537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9538 for as_dir in $PATH
9539 do
9540   IFS=$as_save_IFS
9541   test -z "$as_dir" && as_dir=.
9542   for ac_exec_ext in '' $ac_executable_extensions; do
9543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9544     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9546     break 2
9547   fi
9548 done
9549 done
9550
9551 fi
9552 fi
9553 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9554 if test -n "$AR_FOR_TARGET"; then
9555   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9556 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9557 else
9558   echo "$as_me:$LINENO: result: no" >&5
9559 echo "${ECHO_T}no" >&6
9560 fi
9561
9562   done
9563 fi
9564
9565 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9566   for ncn_progname in ar; do
9567     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9568 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9569     if test -x $with_build_time_tools/${ncn_progname}; then
9570       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9571       echo "$as_me:$LINENO: result: yes" >&5
9572 echo "${ECHO_T}yes" >&6
9573       break
9574     else
9575       echo "$as_me:$LINENO: result: no" >&5
9576 echo "${ECHO_T}no" >&6
9577     fi
9578   done
9579 fi
9580
9581 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9582   for ncn_progname in ar; do
9583     if test -n "$ncn_target_tool_prefix"; then
9584       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9585 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_AR_FOR_TARGET+set}" = set; then
9589   echo $ECHO_N "(cached) $ECHO_C" >&6
9590 else
9591   if test -n "$AR_FOR_TARGET"; then
9592   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9593 else
9594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9595 for as_dir in $PATH
9596 do
9597   IFS=$as_save_IFS
9598   test -z "$as_dir" && as_dir=.
9599   for ac_exec_ext in '' $ac_executable_extensions; do
9600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9601     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9603     break 2
9604   fi
9605 done
9606 done
9607
9608 fi
9609 fi
9610 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9611 if test -n "$AR_FOR_TARGET"; then
9612   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9613 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9614 else
9615   echo "$as_me:$LINENO: result: no" >&5
9616 echo "${ECHO_T}no" >&6
9617 fi
9618
9619     fi
9620     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9621       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9622 set dummy ${ncn_progname}; ac_word=$2
9623 echo "$as_me:$LINENO: checking for $ac_word" >&5
9624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9625 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9626   echo $ECHO_N "(cached) $ECHO_C" >&6
9627 else
9628   if test -n "$AR_FOR_TARGET"; then
9629   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9630 else
9631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9632 for as_dir in $PATH
9633 do
9634   IFS=$as_save_IFS
9635   test -z "$as_dir" && as_dir=.
9636   for ac_exec_ext in '' $ac_executable_extensions; do
9637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9638     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9640     break 2
9641   fi
9642 done
9643 done
9644
9645 fi
9646 fi
9647 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9648 if test -n "$AR_FOR_TARGET"; then
9649   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9650 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9651 else
9652   echo "$as_me:$LINENO: result: no" >&5
9653 echo "${ECHO_T}no" >&6
9654 fi
9655
9656     fi
9657     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9658   done
9659 fi
9660
9661 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9662   set dummy ar
9663   if test $build = $target ; then
9664     AR_FOR_TARGET="$2"
9665   else
9666     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9667   fi
9668 else
9669   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9670 fi
9671
9672 else
9673   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9674 fi
9675
9676
9677
9678
9679 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9680   if test -n "$with_build_time_tools"; then
9681     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9682 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9683     if test -x $with_build_time_tools/as; then
9684       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9685       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9686       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9687 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9688     else
9689       echo "$as_me:$LINENO: result: no" >&5
9690 echo "${ECHO_T}no" >&6
9691     fi
9692   elif test $build != $host && test $have_gcc_for_target = yes; then
9693     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9694     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9695     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9696   fi
9697 fi
9698 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9699   # Extract the first word of "as", so it can be a program name with args.
9700 set dummy as; ac_word=$2
9701 echo "$as_me:$LINENO: checking for $ac_word" >&5
9702 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9703 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9704   echo $ECHO_N "(cached) $ECHO_C" >&6
9705 else
9706   case $AS_FOR_TARGET in
9707   [\\/]* | ?:[\\/]*)
9708   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9709   ;;
9710   *)
9711   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9712 for as_dir in $gcc_cv_tool_dirs
9713 do
9714   IFS=$as_save_IFS
9715   test -z "$as_dir" && as_dir=.
9716   for ac_exec_ext in '' $ac_executable_extensions; do
9717   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9718     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9719     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9720     break 2
9721   fi
9722 done
9723 done
9724
9725   ;;
9726 esac
9727 fi
9728 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9729
9730 if test -n "$AS_FOR_TARGET"; then
9731   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9732 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9733 else
9734   echo "$as_me:$LINENO: result: no" >&5
9735 echo "${ECHO_T}no" >&6
9736 fi
9737
9738 fi
9739 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9740
9741
9742 if test -n "$AS_FOR_TARGET"; then
9743   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9744 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9745   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9746 fi
9747
9748 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9749   for ncn_progname in as; do
9750     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9751 set dummy ${ncn_progname}; ac_word=$2
9752 echo "$as_me:$LINENO: checking for $ac_word" >&5
9753 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9754 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9755   echo $ECHO_N "(cached) $ECHO_C" >&6
9756 else
9757   if test -n "$AS_FOR_TARGET"; then
9758   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9759 else
9760 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9761 for as_dir in $PATH
9762 do
9763   IFS=$as_save_IFS
9764   test -z "$as_dir" && as_dir=.
9765   for ac_exec_ext in '' $ac_executable_extensions; do
9766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9767     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9769     break 2
9770   fi
9771 done
9772 done
9773
9774 fi
9775 fi
9776 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9777 if test -n "$AS_FOR_TARGET"; then
9778   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9779 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9780 else
9781   echo "$as_me:$LINENO: result: no" >&5
9782 echo "${ECHO_T}no" >&6
9783 fi
9784
9785   done
9786 fi
9787
9788 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9789   for ncn_progname in as; do
9790     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9791 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9792     if test -x $with_build_time_tools/${ncn_progname}; then
9793       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9794       echo "$as_me:$LINENO: result: yes" >&5
9795 echo "${ECHO_T}yes" >&6
9796       break
9797     else
9798       echo "$as_me:$LINENO: result: no" >&5
9799 echo "${ECHO_T}no" >&6
9800     fi
9801   done
9802 fi
9803
9804 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9805   for ncn_progname in as; do
9806     if test -n "$ncn_target_tool_prefix"; then
9807       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9808 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_AS_FOR_TARGET+set}" = set; then
9812   echo $ECHO_N "(cached) $ECHO_C" >&6
9813 else
9814   if test -n "$AS_FOR_TARGET"; then
9815   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9816 else
9817 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9818 for as_dir in $PATH
9819 do
9820   IFS=$as_save_IFS
9821   test -z "$as_dir" && as_dir=.
9822   for ac_exec_ext in '' $ac_executable_extensions; do
9823   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9824     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9825     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9826     break 2
9827   fi
9828 done
9829 done
9830
9831 fi
9832 fi
9833 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9834 if test -n "$AS_FOR_TARGET"; then
9835   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9836 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9837 else
9838   echo "$as_me:$LINENO: result: no" >&5
9839 echo "${ECHO_T}no" >&6
9840 fi
9841
9842     fi
9843     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9844       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9845 set dummy ${ncn_progname}; ac_word=$2
9846 echo "$as_me:$LINENO: checking for $ac_word" >&5
9847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9848 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9849   echo $ECHO_N "(cached) $ECHO_C" >&6
9850 else
9851   if test -n "$AS_FOR_TARGET"; then
9852   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9853 else
9854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9855 for as_dir in $PATH
9856 do
9857   IFS=$as_save_IFS
9858   test -z "$as_dir" && as_dir=.
9859   for ac_exec_ext in '' $ac_executable_extensions; do
9860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9861     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9863     break 2
9864   fi
9865 done
9866 done
9867
9868 fi
9869 fi
9870 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9871 if test -n "$AS_FOR_TARGET"; then
9872   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9873 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9874 else
9875   echo "$as_me:$LINENO: result: no" >&5
9876 echo "${ECHO_T}no" >&6
9877 fi
9878
9879     fi
9880     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9881   done
9882 fi
9883
9884 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9885   set dummy as
9886   if test $build = $target ; then
9887     AS_FOR_TARGET="$2"
9888   else
9889     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9890   fi
9891 else
9892   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9893 fi
9894
9895 else
9896   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9897 fi
9898
9899
9900
9901
9902 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9903   if test -n "$with_build_time_tools"; then
9904     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9905 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9906     if test -x $with_build_time_tools/dlltool; then
9907       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9908       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9909       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9910 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9911     else
9912       echo "$as_me:$LINENO: result: no" >&5
9913 echo "${ECHO_T}no" >&6
9914     fi
9915   elif test $build != $host && test $have_gcc_for_target = yes; then
9916     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9917     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9918     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9919   fi
9920 fi
9921 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9922   # Extract the first word of "dlltool", so it can be a program name with args.
9923 set dummy dlltool; ac_word=$2
9924 echo "$as_me:$LINENO: checking for $ac_word" >&5
9925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9926 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9927   echo $ECHO_N "(cached) $ECHO_C" >&6
9928 else
9929   case $DLLTOOL_FOR_TARGET in
9930   [\\/]* | ?:[\\/]*)
9931   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9932   ;;
9933   *)
9934   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9935 for as_dir in $gcc_cv_tool_dirs
9936 do
9937   IFS=$as_save_IFS
9938   test -z "$as_dir" && as_dir=.
9939   for ac_exec_ext in '' $ac_executable_extensions; do
9940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9941     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9943     break 2
9944   fi
9945 done
9946 done
9947
9948   ;;
9949 esac
9950 fi
9951 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9952
9953 if test -n "$DLLTOOL_FOR_TARGET"; then
9954   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9955 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9956 else
9957   echo "$as_me:$LINENO: result: no" >&5
9958 echo "${ECHO_T}no" >&6
9959 fi
9960
9961 fi
9962 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9963
9964
9965 if test -n "$DLLTOOL_FOR_TARGET"; then
9966   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9967 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9968   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9969 fi
9970
9971 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9972   for ncn_progname in dlltool; do
9973     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9974 set dummy ${ncn_progname}; ac_word=$2
9975 echo "$as_me:$LINENO: checking for $ac_word" >&5
9976 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9977 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9978   echo $ECHO_N "(cached) $ECHO_C" >&6
9979 else
9980   if test -n "$DLLTOOL_FOR_TARGET"; then
9981   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9982 else
9983 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9984 for as_dir in $PATH
9985 do
9986   IFS=$as_save_IFS
9987   test -z "$as_dir" && as_dir=.
9988   for ac_exec_ext in '' $ac_executable_extensions; do
9989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9990     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9992     break 2
9993   fi
9994 done
9995 done
9996
9997 fi
9998 fi
9999 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10000 if test -n "$DLLTOOL_FOR_TARGET"; then
10001   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10002 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10003 else
10004   echo "$as_me:$LINENO: result: no" >&5
10005 echo "${ECHO_T}no" >&6
10006 fi
10007
10008   done
10009 fi
10010
10011 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
10012   for ncn_progname in dlltool; do
10013     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10014 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10015     if test -x $with_build_time_tools/${ncn_progname}; then
10016       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10017       echo "$as_me:$LINENO: result: yes" >&5
10018 echo "${ECHO_T}yes" >&6
10019       break
10020     else
10021       echo "$as_me:$LINENO: result: no" >&5
10022 echo "${ECHO_T}no" >&6
10023     fi
10024   done
10025 fi
10026
10027 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
10028   for ncn_progname in dlltool; do
10029     if test -n "$ncn_target_tool_prefix"; then
10030       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10031 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10035   echo $ECHO_N "(cached) $ECHO_C" >&6
10036 else
10037   if test -n "$DLLTOOL_FOR_TARGET"; then
10038   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10039 else
10040 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10041 for as_dir in $PATH
10042 do
10043   IFS=$as_save_IFS
10044   test -z "$as_dir" && as_dir=.
10045   for ac_exec_ext in '' $ac_executable_extensions; do
10046   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10047     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10048     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10049     break 2
10050   fi
10051 done
10052 done
10053
10054 fi
10055 fi
10056 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10057 if test -n "$DLLTOOL_FOR_TARGET"; then
10058   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10059 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10060 else
10061   echo "$as_me:$LINENO: result: no" >&5
10062 echo "${ECHO_T}no" >&6
10063 fi
10064
10065     fi
10066     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
10067       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10068 set dummy ${ncn_progname}; ac_word=$2
10069 echo "$as_me:$LINENO: checking for $ac_word" >&5
10070 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10071 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
10072   echo $ECHO_N "(cached) $ECHO_C" >&6
10073 else
10074   if test -n "$DLLTOOL_FOR_TARGET"; then
10075   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
10076 else
10077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10078 for as_dir in $PATH
10079 do
10080   IFS=$as_save_IFS
10081   test -z "$as_dir" && as_dir=.
10082   for ac_exec_ext in '' $ac_executable_extensions; do
10083   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10084     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
10085     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10086     break 2
10087   fi
10088 done
10089 done
10090
10091 fi
10092 fi
10093 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
10094 if test -n "$DLLTOOL_FOR_TARGET"; then
10095   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
10096 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
10097 else
10098   echo "$as_me:$LINENO: result: no" >&5
10099 echo "${ECHO_T}no" >&6
10100 fi
10101
10102     fi
10103     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
10104   done
10105 fi
10106
10107 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
10108   set dummy dlltool
10109   if test $build = $target ; then
10110     DLLTOOL_FOR_TARGET="$2"
10111   else
10112     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
10113   fi
10114 else
10115   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
10116 fi
10117
10118 else
10119   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
10120 fi
10121
10122
10123
10124
10125 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10126   if test -n "$with_build_time_tools"; then
10127     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
10128 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
10129     if test -x $with_build_time_tools/ld; then
10130       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
10131       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10132       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
10133 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
10134     else
10135       echo "$as_me:$LINENO: result: no" >&5
10136 echo "${ECHO_T}no" >&6
10137     fi
10138   elif test $build != $host && test $have_gcc_for_target = yes; then
10139     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
10140     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
10141     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
10142   fi
10143 fi
10144 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10145   # Extract the first word of "ld", so it can be a program name with args.
10146 set dummy ld; ac_word=$2
10147 echo "$as_me:$LINENO: checking for $ac_word" >&5
10148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10149 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
10150   echo $ECHO_N "(cached) $ECHO_C" >&6
10151 else
10152   case $LD_FOR_TARGET in
10153   [\\/]* | ?:[\\/]*)
10154   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
10155   ;;
10156   *)
10157   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10158 for as_dir in $gcc_cv_tool_dirs
10159 do
10160   IFS=$as_save_IFS
10161   test -z "$as_dir" && as_dir=.
10162   for ac_exec_ext in '' $ac_executable_extensions; do
10163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10164     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10166     break 2
10167   fi
10168 done
10169 done
10170
10171   ;;
10172 esac
10173 fi
10174 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10175
10176 if test -n "$LD_FOR_TARGET"; then
10177   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10178 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10179 else
10180   echo "$as_me:$LINENO: result: no" >&5
10181 echo "${ECHO_T}no" >&6
10182 fi
10183
10184 fi
10185 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
10186
10187
10188 if test -n "$LD_FOR_TARGET"; then
10189   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
10190 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10191   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10192 fi
10193
10194 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
10195   for ncn_progname in ld; do
10196     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10197 set dummy ${ncn_progname}; ac_word=$2
10198 echo "$as_me:$LINENO: checking for $ac_word" >&5
10199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10200 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10201   echo $ECHO_N "(cached) $ECHO_C" >&6
10202 else
10203   if test -n "$LD_FOR_TARGET"; then
10204   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10205 else
10206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10207 for as_dir in $PATH
10208 do
10209   IFS=$as_save_IFS
10210   test -z "$as_dir" && as_dir=.
10211   for ac_exec_ext in '' $ac_executable_extensions; do
10212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10213     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10215     break 2
10216   fi
10217 done
10218 done
10219
10220 fi
10221 fi
10222 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10223 if test -n "$LD_FOR_TARGET"; then
10224   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10225 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10226 else
10227   echo "$as_me:$LINENO: result: no" >&5
10228 echo "${ECHO_T}no" >&6
10229 fi
10230
10231   done
10232 fi
10233
10234 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
10235   for ncn_progname in ld; do
10236     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10237 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10238     if test -x $with_build_time_tools/${ncn_progname}; then
10239       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10240       echo "$as_me:$LINENO: result: yes" >&5
10241 echo "${ECHO_T}yes" >&6
10242       break
10243     else
10244       echo "$as_me:$LINENO: result: no" >&5
10245 echo "${ECHO_T}no" >&6
10246     fi
10247   done
10248 fi
10249
10250 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10251   for ncn_progname in ld; do
10252     if test -n "$ncn_target_tool_prefix"; then
10253       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10254 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_LD_FOR_TARGET+set}" = set; then
10258   echo $ECHO_N "(cached) $ECHO_C" >&6
10259 else
10260   if test -n "$LD_FOR_TARGET"; then
10261   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10262 else
10263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10264 for as_dir in $PATH
10265 do
10266   IFS=$as_save_IFS
10267   test -z "$as_dir" && as_dir=.
10268   for ac_exec_ext in '' $ac_executable_extensions; do
10269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10270     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10272     break 2
10273   fi
10274 done
10275 done
10276
10277 fi
10278 fi
10279 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10280 if test -n "$LD_FOR_TARGET"; then
10281   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10282 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10283 else
10284   echo "$as_me:$LINENO: result: no" >&5
10285 echo "${ECHO_T}no" >&6
10286 fi
10287
10288     fi
10289     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10290       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10291 set dummy ${ncn_progname}; ac_word=$2
10292 echo "$as_me:$LINENO: checking for $ac_word" >&5
10293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10294 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10295   echo $ECHO_N "(cached) $ECHO_C" >&6
10296 else
10297   if test -n "$LD_FOR_TARGET"; then
10298   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10299 else
10300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10301 for as_dir in $PATH
10302 do
10303   IFS=$as_save_IFS
10304   test -z "$as_dir" && as_dir=.
10305   for ac_exec_ext in '' $ac_executable_extensions; do
10306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10307     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10309     break 2
10310   fi
10311 done
10312 done
10313
10314 fi
10315 fi
10316 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10317 if test -n "$LD_FOR_TARGET"; then
10318   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10319 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10320 else
10321   echo "$as_me:$LINENO: result: no" >&5
10322 echo "${ECHO_T}no" >&6
10323 fi
10324
10325     fi
10326     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10327   done
10328 fi
10329
10330 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10331   set dummy ld
10332   if test $build = $target ; then
10333     LD_FOR_TARGET="$2"
10334   else
10335     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10336   fi
10337 else
10338   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10339 fi
10340
10341 else
10342   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10343 fi
10344
10345
10346
10347
10348 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10349   if test -n "$with_build_time_tools"; then
10350     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10351 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10352     if test -x $with_build_time_tools/lipo; then
10353       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10354       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10355       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10356 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10357     else
10358       echo "$as_me:$LINENO: result: no" >&5
10359 echo "${ECHO_T}no" >&6
10360     fi
10361   elif test $build != $host && test $have_gcc_for_target = yes; then
10362     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10363     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10364     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10365   fi
10366 fi
10367 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10368   # Extract the first word of "lipo", so it can be a program name with args.
10369 set dummy lipo; ac_word=$2
10370 echo "$as_me:$LINENO: checking for $ac_word" >&5
10371 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10372 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10373   echo $ECHO_N "(cached) $ECHO_C" >&6
10374 else
10375   case $LIPO_FOR_TARGET in
10376   [\\/]* | ?:[\\/]*)
10377   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10378   ;;
10379   *)
10380   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10381 for as_dir in $gcc_cv_tool_dirs
10382 do
10383   IFS=$as_save_IFS
10384   test -z "$as_dir" && as_dir=.
10385   for ac_exec_ext in '' $ac_executable_extensions; do
10386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10387     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10389     break 2
10390   fi
10391 done
10392 done
10393
10394   ;;
10395 esac
10396 fi
10397 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10398
10399 if test -n "$LIPO_FOR_TARGET"; then
10400   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10401 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10402 else
10403   echo "$as_me:$LINENO: result: no" >&5
10404 echo "${ECHO_T}no" >&6
10405 fi
10406
10407 fi
10408 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10409
10410
10411 if test -n "$LIPO_FOR_TARGET"; then
10412   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10413 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10414   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10415 fi
10416
10417 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10418   for ncn_progname in lipo; do
10419     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10420 set dummy ${ncn_progname}; ac_word=$2
10421 echo "$as_me:$LINENO: checking for $ac_word" >&5
10422 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10423 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10424   echo $ECHO_N "(cached) $ECHO_C" >&6
10425 else
10426   if test -n "$LIPO_FOR_TARGET"; then
10427   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10428 else
10429 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10430 for as_dir in $PATH
10431 do
10432   IFS=$as_save_IFS
10433   test -z "$as_dir" && as_dir=.
10434   for ac_exec_ext in '' $ac_executable_extensions; do
10435   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10436     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10437     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10438     break 2
10439   fi
10440 done
10441 done
10442
10443 fi
10444 fi
10445 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10446 if test -n "$LIPO_FOR_TARGET"; then
10447   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10448 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10449 else
10450   echo "$as_me:$LINENO: result: no" >&5
10451 echo "${ECHO_T}no" >&6
10452 fi
10453
10454   done
10455 fi
10456
10457 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10458   for ncn_progname in lipo; do
10459     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10460 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10461     if test -x $with_build_time_tools/${ncn_progname}; then
10462       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10463       echo "$as_me:$LINENO: result: yes" >&5
10464 echo "${ECHO_T}yes" >&6
10465       break
10466     else
10467       echo "$as_me:$LINENO: result: no" >&5
10468 echo "${ECHO_T}no" >&6
10469     fi
10470   done
10471 fi
10472
10473 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10474   for ncn_progname in lipo; do
10475     if test -n "$ncn_target_tool_prefix"; then
10476       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10477 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_LIPO_FOR_TARGET+set}" = set; then
10481   echo $ECHO_N "(cached) $ECHO_C" >&6
10482 else
10483   if test -n "$LIPO_FOR_TARGET"; then
10484   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10485 else
10486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10487 for as_dir in $PATH
10488 do
10489   IFS=$as_save_IFS
10490   test -z "$as_dir" && as_dir=.
10491   for ac_exec_ext in '' $ac_executable_extensions; do
10492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10493     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10495     break 2
10496   fi
10497 done
10498 done
10499
10500 fi
10501 fi
10502 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10503 if test -n "$LIPO_FOR_TARGET"; then
10504   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10505 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10506 else
10507   echo "$as_me:$LINENO: result: no" >&5
10508 echo "${ECHO_T}no" >&6
10509 fi
10510
10511     fi
10512     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10513       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10514 set dummy ${ncn_progname}; ac_word=$2
10515 echo "$as_me:$LINENO: checking for $ac_word" >&5
10516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10517 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10518   echo $ECHO_N "(cached) $ECHO_C" >&6
10519 else
10520   if test -n "$LIPO_FOR_TARGET"; then
10521   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10522 else
10523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10524 for as_dir in $PATH
10525 do
10526   IFS=$as_save_IFS
10527   test -z "$as_dir" && as_dir=.
10528   for ac_exec_ext in '' $ac_executable_extensions; do
10529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10530     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10532     break 2
10533   fi
10534 done
10535 done
10536
10537 fi
10538 fi
10539 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10540 if test -n "$LIPO_FOR_TARGET"; then
10541   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10542 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10543 else
10544   echo "$as_me:$LINENO: result: no" >&5
10545 echo "${ECHO_T}no" >&6
10546 fi
10547
10548     fi
10549     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10550   done
10551 fi
10552
10553 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10554   set dummy lipo
10555   if test $build = $target ; then
10556     LIPO_FOR_TARGET="$2"
10557   else
10558     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10559   fi
10560 else
10561   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10562 fi
10563
10564 else
10565   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10566 fi
10567
10568
10569
10570
10571 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10572   if test -n "$with_build_time_tools"; then
10573     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10574 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10575     if test -x $with_build_time_tools/nm; then
10576       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10577       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10578       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10579 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10580     else
10581       echo "$as_me:$LINENO: result: no" >&5
10582 echo "${ECHO_T}no" >&6
10583     fi
10584   elif test $build != $host && test $have_gcc_for_target = yes; then
10585     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10586     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10587     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10588   fi
10589 fi
10590 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10591   # Extract the first word of "nm", so it can be a program name with args.
10592 set dummy nm; ac_word=$2
10593 echo "$as_me:$LINENO: checking for $ac_word" >&5
10594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10595 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10596   echo $ECHO_N "(cached) $ECHO_C" >&6
10597 else
10598   case $NM_FOR_TARGET in
10599   [\\/]* | ?:[\\/]*)
10600   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10601   ;;
10602   *)
10603   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10604 for as_dir in $gcc_cv_tool_dirs
10605 do
10606   IFS=$as_save_IFS
10607   test -z "$as_dir" && as_dir=.
10608   for ac_exec_ext in '' $ac_executable_extensions; do
10609   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10610     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10611     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10612     break 2
10613   fi
10614 done
10615 done
10616
10617   ;;
10618 esac
10619 fi
10620 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10621
10622 if test -n "$NM_FOR_TARGET"; then
10623   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10624 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10625 else
10626   echo "$as_me:$LINENO: result: no" >&5
10627 echo "${ECHO_T}no" >&6
10628 fi
10629
10630 fi
10631 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10632
10633
10634 if test -n "$NM_FOR_TARGET"; then
10635   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10636 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10637   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10638 fi
10639
10640 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10641   for ncn_progname in nm; do
10642     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10643 set dummy ${ncn_progname}; ac_word=$2
10644 echo "$as_me:$LINENO: checking for $ac_word" >&5
10645 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10646 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10647   echo $ECHO_N "(cached) $ECHO_C" >&6
10648 else
10649   if test -n "$NM_FOR_TARGET"; then
10650   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10651 else
10652 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10653 for as_dir in $PATH
10654 do
10655   IFS=$as_save_IFS
10656   test -z "$as_dir" && as_dir=.
10657   for ac_exec_ext in '' $ac_executable_extensions; do
10658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10659     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10661     break 2
10662   fi
10663 done
10664 done
10665
10666 fi
10667 fi
10668 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10669 if test -n "$NM_FOR_TARGET"; then
10670   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10671 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10672 else
10673   echo "$as_me:$LINENO: result: no" >&5
10674 echo "${ECHO_T}no" >&6
10675 fi
10676
10677   done
10678 fi
10679
10680 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10681   for ncn_progname in nm; do
10682     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10683 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10684     if test -x $with_build_time_tools/${ncn_progname}; then
10685       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10686       echo "$as_me:$LINENO: result: yes" >&5
10687 echo "${ECHO_T}yes" >&6
10688       break
10689     else
10690       echo "$as_me:$LINENO: result: no" >&5
10691 echo "${ECHO_T}no" >&6
10692     fi
10693   done
10694 fi
10695
10696 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10697   for ncn_progname in nm; do
10698     if test -n "$ncn_target_tool_prefix"; then
10699       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10700 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_NM_FOR_TARGET+set}" = set; then
10704   echo $ECHO_N "(cached) $ECHO_C" >&6
10705 else
10706   if test -n "$NM_FOR_TARGET"; then
10707   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10708 else
10709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10710 for as_dir in $PATH
10711 do
10712   IFS=$as_save_IFS
10713   test -z "$as_dir" && as_dir=.
10714   for ac_exec_ext in '' $ac_executable_extensions; do
10715   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10716     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10717     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10718     break 2
10719   fi
10720 done
10721 done
10722
10723 fi
10724 fi
10725 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10726 if test -n "$NM_FOR_TARGET"; then
10727   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10728 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10729 else
10730   echo "$as_me:$LINENO: result: no" >&5
10731 echo "${ECHO_T}no" >&6
10732 fi
10733
10734     fi
10735     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10736       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10737 set dummy ${ncn_progname}; ac_word=$2
10738 echo "$as_me:$LINENO: checking for $ac_word" >&5
10739 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10740 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10741   echo $ECHO_N "(cached) $ECHO_C" >&6
10742 else
10743   if test -n "$NM_FOR_TARGET"; then
10744   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10745 else
10746 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10747 for as_dir in $PATH
10748 do
10749   IFS=$as_save_IFS
10750   test -z "$as_dir" && as_dir=.
10751   for ac_exec_ext in '' $ac_executable_extensions; do
10752   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10753     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10754     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10755     break 2
10756   fi
10757 done
10758 done
10759
10760 fi
10761 fi
10762 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10763 if test -n "$NM_FOR_TARGET"; then
10764   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10765 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10766 else
10767   echo "$as_me:$LINENO: result: no" >&5
10768 echo "${ECHO_T}no" >&6
10769 fi
10770
10771     fi
10772     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10773   done
10774 fi
10775
10776 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10777   set dummy nm
10778   if test $build = $target ; then
10779     NM_FOR_TARGET="$2"
10780   else
10781     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10782   fi
10783 else
10784   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10785 fi
10786
10787 else
10788   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10789 fi
10790
10791
10792
10793
10794 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10795   if test -n "$with_build_time_tools"; then
10796     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10797 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10798     if test -x $with_build_time_tools/objdump; then
10799       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10800       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10801       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10802 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10803     else
10804       echo "$as_me:$LINENO: result: no" >&5
10805 echo "${ECHO_T}no" >&6
10806     fi
10807   elif test $build != $host && test $have_gcc_for_target = yes; then
10808     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10809     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10810     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10811   fi
10812 fi
10813 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10814   # Extract the first word of "objdump", so it can be a program name with args.
10815 set dummy objdump; ac_word=$2
10816 echo "$as_me:$LINENO: checking for $ac_word" >&5
10817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10818 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10819   echo $ECHO_N "(cached) $ECHO_C" >&6
10820 else
10821   case $OBJDUMP_FOR_TARGET in
10822   [\\/]* | ?:[\\/]*)
10823   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10824   ;;
10825   *)
10826   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10827 for as_dir in $gcc_cv_tool_dirs
10828 do
10829   IFS=$as_save_IFS
10830   test -z "$as_dir" && as_dir=.
10831   for ac_exec_ext in '' $ac_executable_extensions; do
10832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10833     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10835     break 2
10836   fi
10837 done
10838 done
10839
10840   ;;
10841 esac
10842 fi
10843 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10844
10845 if test -n "$OBJDUMP_FOR_TARGET"; then
10846   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10847 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10848 else
10849   echo "$as_me:$LINENO: result: no" >&5
10850 echo "${ECHO_T}no" >&6
10851 fi
10852
10853 fi
10854 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10855
10856
10857 if test -n "$OBJDUMP_FOR_TARGET"; then
10858   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10859 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10860   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10861 fi
10862
10863 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10864   for ncn_progname in objdump; do
10865     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10866 set dummy ${ncn_progname}; ac_word=$2
10867 echo "$as_me:$LINENO: checking for $ac_word" >&5
10868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10869 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10870   echo $ECHO_N "(cached) $ECHO_C" >&6
10871 else
10872   if test -n "$OBJDUMP_FOR_TARGET"; then
10873   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10874 else
10875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10876 for as_dir in $PATH
10877 do
10878   IFS=$as_save_IFS
10879   test -z "$as_dir" && as_dir=.
10880   for ac_exec_ext in '' $ac_executable_extensions; do
10881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10882     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10884     break 2
10885   fi
10886 done
10887 done
10888
10889 fi
10890 fi
10891 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10892 if test -n "$OBJDUMP_FOR_TARGET"; then
10893   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10894 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10895 else
10896   echo "$as_me:$LINENO: result: no" >&5
10897 echo "${ECHO_T}no" >&6
10898 fi
10899
10900   done
10901 fi
10902
10903 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10904   for ncn_progname in objdump; do
10905     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10906 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10907     if test -x $with_build_time_tools/${ncn_progname}; then
10908       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10909       echo "$as_me:$LINENO: result: yes" >&5
10910 echo "${ECHO_T}yes" >&6
10911       break
10912     else
10913       echo "$as_me:$LINENO: result: no" >&5
10914 echo "${ECHO_T}no" >&6
10915     fi
10916   done
10917 fi
10918
10919 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10920   for ncn_progname in objdump; do
10921     if test -n "$ncn_target_tool_prefix"; then
10922       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10923 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10927   echo $ECHO_N "(cached) $ECHO_C" >&6
10928 else
10929   if test -n "$OBJDUMP_FOR_TARGET"; then
10930   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10931 else
10932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10933 for as_dir in $PATH
10934 do
10935   IFS=$as_save_IFS
10936   test -z "$as_dir" && as_dir=.
10937   for ac_exec_ext in '' $ac_executable_extensions; do
10938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10939     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10941     break 2
10942   fi
10943 done
10944 done
10945
10946 fi
10947 fi
10948 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10949 if test -n "$OBJDUMP_FOR_TARGET"; then
10950   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10951 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10952 else
10953   echo "$as_me:$LINENO: result: no" >&5
10954 echo "${ECHO_T}no" >&6
10955 fi
10956
10957     fi
10958     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10959       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10960 set dummy ${ncn_progname}; ac_word=$2
10961 echo "$as_me:$LINENO: checking for $ac_word" >&5
10962 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10963 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10964   echo $ECHO_N "(cached) $ECHO_C" >&6
10965 else
10966   if test -n "$OBJDUMP_FOR_TARGET"; then
10967   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10968 else
10969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10970 for as_dir in $PATH
10971 do
10972   IFS=$as_save_IFS
10973   test -z "$as_dir" && as_dir=.
10974   for ac_exec_ext in '' $ac_executable_extensions; do
10975   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10976     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10977     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10978     break 2
10979   fi
10980 done
10981 done
10982
10983 fi
10984 fi
10985 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10986 if test -n "$OBJDUMP_FOR_TARGET"; then
10987   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10988 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10989 else
10990   echo "$as_me:$LINENO: result: no" >&5
10991 echo "${ECHO_T}no" >&6
10992 fi
10993
10994     fi
10995     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10996   done
10997 fi
10998
10999 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
11000   set dummy objdump
11001   if test $build = $target ; then
11002     OBJDUMP_FOR_TARGET="$2"
11003   else
11004     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11005   fi
11006 else
11007   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
11008 fi
11009
11010 else
11011   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
11012 fi
11013
11014
11015
11016
11017 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11018   if test -n "$with_build_time_tools"; then
11019     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
11020 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
11021     if test -x $with_build_time_tools/ranlib; then
11022       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
11023       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11024       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
11025 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
11026     else
11027       echo "$as_me:$LINENO: result: no" >&5
11028 echo "${ECHO_T}no" >&6
11029     fi
11030   elif test $build != $host && test $have_gcc_for_target = yes; then
11031     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
11032     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
11033     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11034   fi
11035 fi
11036 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11037   # Extract the first word of "ranlib", so it can be a program name with args.
11038 set dummy ranlib; ac_word=$2
11039 echo "$as_me:$LINENO: checking for $ac_word" >&5
11040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11041 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
11042   echo $ECHO_N "(cached) $ECHO_C" >&6
11043 else
11044   case $RANLIB_FOR_TARGET in
11045   [\\/]* | ?:[\\/]*)
11046   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
11047   ;;
11048   *)
11049   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11050 for as_dir in $gcc_cv_tool_dirs
11051 do
11052   IFS=$as_save_IFS
11053   test -z "$as_dir" && as_dir=.
11054   for ac_exec_ext in '' $ac_executable_extensions; do
11055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11056     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11058     break 2
11059   fi
11060 done
11061 done
11062
11063   ;;
11064 esac
11065 fi
11066 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11067
11068 if test -n "$RANLIB_FOR_TARGET"; then
11069   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11070 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11071 else
11072   echo "$as_me:$LINENO: result: no" >&5
11073 echo "${ECHO_T}no" >&6
11074 fi
11075
11076 fi
11077 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
11078
11079
11080 if test -n "$RANLIB_FOR_TARGET"; then
11081   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
11082 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11083   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11084 fi
11085
11086 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11087   for ncn_progname in ranlib; do
11088     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11089 set dummy ${ncn_progname}; ac_word=$2
11090 echo "$as_me:$LINENO: checking for $ac_word" >&5
11091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11092 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11093   echo $ECHO_N "(cached) $ECHO_C" >&6
11094 else
11095   if test -n "$RANLIB_FOR_TARGET"; then
11096   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11097 else
11098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11099 for as_dir in $PATH
11100 do
11101   IFS=$as_save_IFS
11102   test -z "$as_dir" && as_dir=.
11103   for ac_exec_ext in '' $ac_executable_extensions; do
11104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11105     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11107     break 2
11108   fi
11109 done
11110 done
11111
11112 fi
11113 fi
11114 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11115 if test -n "$RANLIB_FOR_TARGET"; then
11116   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11117 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11118 else
11119   echo "$as_me:$LINENO: result: no" >&5
11120 echo "${ECHO_T}no" >&6
11121 fi
11122
11123   done
11124 fi
11125
11126 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
11127   for ncn_progname in ranlib; do
11128     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11129 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11130     if test -x $with_build_time_tools/${ncn_progname}; then
11131       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11132       echo "$as_me:$LINENO: result: yes" >&5
11133 echo "${ECHO_T}yes" >&6
11134       break
11135     else
11136       echo "$as_me:$LINENO: result: no" >&5
11137 echo "${ECHO_T}no" >&6
11138     fi
11139   done
11140 fi
11141
11142 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
11143   for ncn_progname in ranlib; do
11144     if test -n "$ncn_target_tool_prefix"; then
11145       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11146 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_RANLIB_FOR_TARGET+set}" = set; then
11150   echo $ECHO_N "(cached) $ECHO_C" >&6
11151 else
11152   if test -n "$RANLIB_FOR_TARGET"; then
11153   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11154 else
11155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11156 for as_dir in $PATH
11157 do
11158   IFS=$as_save_IFS
11159   test -z "$as_dir" && as_dir=.
11160   for ac_exec_ext in '' $ac_executable_extensions; do
11161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11162     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11164     break 2
11165   fi
11166 done
11167 done
11168
11169 fi
11170 fi
11171 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11172 if test -n "$RANLIB_FOR_TARGET"; then
11173   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11174 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11175 else
11176   echo "$as_me:$LINENO: result: no" >&5
11177 echo "${ECHO_T}no" >&6
11178 fi
11179
11180     fi
11181     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
11182       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11183 set dummy ${ncn_progname}; ac_word=$2
11184 echo "$as_me:$LINENO: checking for $ac_word" >&5
11185 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11186 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
11187   echo $ECHO_N "(cached) $ECHO_C" >&6
11188 else
11189   if test -n "$RANLIB_FOR_TARGET"; then
11190   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
11191 else
11192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11193 for as_dir in $PATH
11194 do
11195   IFS=$as_save_IFS
11196   test -z "$as_dir" && as_dir=.
11197   for ac_exec_ext in '' $ac_executable_extensions; do
11198   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11199     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
11200     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11201     break 2
11202   fi
11203 done
11204 done
11205
11206 fi
11207 fi
11208 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
11209 if test -n "$RANLIB_FOR_TARGET"; then
11210   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
11211 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
11212 else
11213   echo "$as_me:$LINENO: result: no" >&5
11214 echo "${ECHO_T}no" >&6
11215 fi
11216
11217     fi
11218     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
11219   done
11220 fi
11221
11222 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
11223   set dummy ranlib
11224   if test $build = $target ; then
11225     RANLIB_FOR_TARGET="$2"
11226   else
11227     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
11228   fi
11229 else
11230   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
11231 fi
11232
11233 else
11234   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
11235 fi
11236
11237
11238
11239
11240 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11241   if test -n "$with_build_time_tools"; then
11242     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
11243 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
11244     if test -x $with_build_time_tools/strip; then
11245       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
11246       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11247       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11248 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11249     else
11250       echo "$as_me:$LINENO: result: no" >&5
11251 echo "${ECHO_T}no" >&6
11252     fi
11253   elif test $build != $host && test $have_gcc_for_target = yes; then
11254     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11255     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11256     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11257   fi
11258 fi
11259 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11260   # Extract the first word of "strip", so it can be a program name with args.
11261 set dummy strip; ac_word=$2
11262 echo "$as_me:$LINENO: checking for $ac_word" >&5
11263 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11264 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11265   echo $ECHO_N "(cached) $ECHO_C" >&6
11266 else
11267   case $STRIP_FOR_TARGET in
11268   [\\/]* | ?:[\\/]*)
11269   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11270   ;;
11271   *)
11272   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11273 for as_dir in $gcc_cv_tool_dirs
11274 do
11275   IFS=$as_save_IFS
11276   test -z "$as_dir" && as_dir=.
11277   for ac_exec_ext in '' $ac_executable_extensions; do
11278   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11279     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11280     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11281     break 2
11282   fi
11283 done
11284 done
11285
11286   ;;
11287 esac
11288 fi
11289 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11290
11291 if test -n "$STRIP_FOR_TARGET"; then
11292   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11293 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11294 else
11295   echo "$as_me:$LINENO: result: no" >&5
11296 echo "${ECHO_T}no" >&6
11297 fi
11298
11299 fi
11300 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11301
11302
11303 if test -n "$STRIP_FOR_TARGET"; then
11304   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11305 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11306   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11307 fi
11308
11309 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11310   for ncn_progname in strip; do
11311     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11312 set dummy ${ncn_progname}; ac_word=$2
11313 echo "$as_me:$LINENO: checking for $ac_word" >&5
11314 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11315 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11316   echo $ECHO_N "(cached) $ECHO_C" >&6
11317 else
11318   if test -n "$STRIP_FOR_TARGET"; then
11319   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11320 else
11321 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11322 for as_dir in $PATH
11323 do
11324   IFS=$as_save_IFS
11325   test -z "$as_dir" && as_dir=.
11326   for ac_exec_ext in '' $ac_executable_extensions; do
11327   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11328     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11329     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11330     break 2
11331   fi
11332 done
11333 done
11334
11335 fi
11336 fi
11337 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11338 if test -n "$STRIP_FOR_TARGET"; then
11339   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11340 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11341 else
11342   echo "$as_me:$LINENO: result: no" >&5
11343 echo "${ECHO_T}no" >&6
11344 fi
11345
11346   done
11347 fi
11348
11349 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11350   for ncn_progname in strip; do
11351     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11352 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11353     if test -x $with_build_time_tools/${ncn_progname}; then
11354       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11355       echo "$as_me:$LINENO: result: yes" >&5
11356 echo "${ECHO_T}yes" >&6
11357       break
11358     else
11359       echo "$as_me:$LINENO: result: no" >&5
11360 echo "${ECHO_T}no" >&6
11361     fi
11362   done
11363 fi
11364
11365 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11366   for ncn_progname in strip; do
11367     if test -n "$ncn_target_tool_prefix"; then
11368       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11369 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_STRIP_FOR_TARGET+set}" = set; then
11373   echo $ECHO_N "(cached) $ECHO_C" >&6
11374 else
11375   if test -n "$STRIP_FOR_TARGET"; then
11376   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11377 else
11378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11379 for as_dir in $PATH
11380 do
11381   IFS=$as_save_IFS
11382   test -z "$as_dir" && as_dir=.
11383   for ac_exec_ext in '' $ac_executable_extensions; do
11384   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11385     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11386     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11387     break 2
11388   fi
11389 done
11390 done
11391
11392 fi
11393 fi
11394 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11395 if test -n "$STRIP_FOR_TARGET"; then
11396   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11397 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11398 else
11399   echo "$as_me:$LINENO: result: no" >&5
11400 echo "${ECHO_T}no" >&6
11401 fi
11402
11403     fi
11404     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11405       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11406 set dummy ${ncn_progname}; ac_word=$2
11407 echo "$as_me:$LINENO: checking for $ac_word" >&5
11408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11409 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11410   echo $ECHO_N "(cached) $ECHO_C" >&6
11411 else
11412   if test -n "$STRIP_FOR_TARGET"; then
11413   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11414 else
11415 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11416 for as_dir in $PATH
11417 do
11418   IFS=$as_save_IFS
11419   test -z "$as_dir" && as_dir=.
11420   for ac_exec_ext in '' $ac_executable_extensions; do
11421   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11422     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11423     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11424     break 2
11425   fi
11426 done
11427 done
11428
11429 fi
11430 fi
11431 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11432 if test -n "$STRIP_FOR_TARGET"; then
11433   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11434 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11435 else
11436   echo "$as_me:$LINENO: result: no" >&5
11437 echo "${ECHO_T}no" >&6
11438 fi
11439
11440     fi
11441     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11442   done
11443 fi
11444
11445 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11446   set dummy strip
11447   if test $build = $target ; then
11448     STRIP_FOR_TARGET="$2"
11449   else
11450     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11451   fi
11452 else
11453   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11454 fi
11455
11456 else
11457   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11458 fi
11459
11460
11461
11462
11463 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11464   if test -n "$with_build_time_tools"; then
11465     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11466 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11467     if test -x $with_build_time_tools/windres; then
11468       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11469       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11470       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11471 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11472     else
11473       echo "$as_me:$LINENO: result: no" >&5
11474 echo "${ECHO_T}no" >&6
11475     fi
11476   elif test $build != $host && test $have_gcc_for_target = yes; then
11477     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11478     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11479     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11480   fi
11481 fi
11482 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11483   # Extract the first word of "windres", so it can be a program name with args.
11484 set dummy windres; ac_word=$2
11485 echo "$as_me:$LINENO: checking for $ac_word" >&5
11486 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11487 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11488   echo $ECHO_N "(cached) $ECHO_C" >&6
11489 else
11490   case $WINDRES_FOR_TARGET in
11491   [\\/]* | ?:[\\/]*)
11492   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11493   ;;
11494   *)
11495   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11496 for as_dir in $gcc_cv_tool_dirs
11497 do
11498   IFS=$as_save_IFS
11499   test -z "$as_dir" && as_dir=.
11500   for ac_exec_ext in '' $ac_executable_extensions; do
11501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11502     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11504     break 2
11505   fi
11506 done
11507 done
11508
11509   ;;
11510 esac
11511 fi
11512 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11513
11514 if test -n "$WINDRES_FOR_TARGET"; then
11515   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11516 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11517 else
11518   echo "$as_me:$LINENO: result: no" >&5
11519 echo "${ECHO_T}no" >&6
11520 fi
11521
11522 fi
11523 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11524
11525
11526 if test -n "$WINDRES_FOR_TARGET"; then
11527   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11528 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11529   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11530 fi
11531
11532 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11533   for ncn_progname in windres; do
11534     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11535 set dummy ${ncn_progname}; ac_word=$2
11536 echo "$as_me:$LINENO: checking for $ac_word" >&5
11537 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11538 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11539   echo $ECHO_N "(cached) $ECHO_C" >&6
11540 else
11541   if test -n "$WINDRES_FOR_TARGET"; then
11542   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11543 else
11544 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11545 for as_dir in $PATH
11546 do
11547   IFS=$as_save_IFS
11548   test -z "$as_dir" && as_dir=.
11549   for ac_exec_ext in '' $ac_executable_extensions; do
11550   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11551     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11552     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11553     break 2
11554   fi
11555 done
11556 done
11557
11558 fi
11559 fi
11560 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11561 if test -n "$WINDRES_FOR_TARGET"; then
11562   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11563 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11564 else
11565   echo "$as_me:$LINENO: result: no" >&5
11566 echo "${ECHO_T}no" >&6
11567 fi
11568
11569   done
11570 fi
11571
11572 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11573   for ncn_progname in windres; do
11574     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11575 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11576     if test -x $with_build_time_tools/${ncn_progname}; then
11577       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11578       echo "$as_me:$LINENO: result: yes" >&5
11579 echo "${ECHO_T}yes" >&6
11580       break
11581     else
11582       echo "$as_me:$LINENO: result: no" >&5
11583 echo "${ECHO_T}no" >&6
11584     fi
11585   done
11586 fi
11587
11588 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11589   for ncn_progname in windres; do
11590     if test -n "$ncn_target_tool_prefix"; then
11591       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11592 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_WINDRES_FOR_TARGET+set}" = set; then
11596   echo $ECHO_N "(cached) $ECHO_C" >&6
11597 else
11598   if test -n "$WINDRES_FOR_TARGET"; then
11599   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11600 else
11601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11602 for as_dir in $PATH
11603 do
11604   IFS=$as_save_IFS
11605   test -z "$as_dir" && as_dir=.
11606   for ac_exec_ext in '' $ac_executable_extensions; do
11607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11608     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11610     break 2
11611   fi
11612 done
11613 done
11614
11615 fi
11616 fi
11617 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11618 if test -n "$WINDRES_FOR_TARGET"; then
11619   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11620 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11621 else
11622   echo "$as_me:$LINENO: result: no" >&5
11623 echo "${ECHO_T}no" >&6
11624 fi
11625
11626     fi
11627     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11628       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11629 set dummy ${ncn_progname}; ac_word=$2
11630 echo "$as_me:$LINENO: checking for $ac_word" >&5
11631 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11632 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11633   echo $ECHO_N "(cached) $ECHO_C" >&6
11634 else
11635   if test -n "$WINDRES_FOR_TARGET"; then
11636   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11637 else
11638 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11639 for as_dir in $PATH
11640 do
11641   IFS=$as_save_IFS
11642   test -z "$as_dir" && as_dir=.
11643   for ac_exec_ext in '' $ac_executable_extensions; do
11644   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11645     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11646     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11647     break 2
11648   fi
11649 done
11650 done
11651
11652 fi
11653 fi
11654 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11655 if test -n "$WINDRES_FOR_TARGET"; then
11656   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11657 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11658 else
11659   echo "$as_me:$LINENO: result: no" >&5
11660 echo "${ECHO_T}no" >&6
11661 fi
11662
11663     fi
11664     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11665   done
11666 fi
11667
11668 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11669   set dummy windres
11670   if test $build = $target ; then
11671     WINDRES_FOR_TARGET="$2"
11672   else
11673     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11674   fi
11675 else
11676   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11677 fi
11678
11679 else
11680   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11681 fi
11682
11683
11684
11685
11686 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11687   if test -n "$with_build_time_tools"; then
11688     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11689 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11690     if test -x $with_build_time_tools/windmc; then
11691       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11692       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11693       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11694 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11695     else
11696       echo "$as_me:$LINENO: result: no" >&5
11697 echo "${ECHO_T}no" >&6
11698     fi
11699   elif test $build != $host && test $have_gcc_for_target = yes; then
11700     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11701     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11702     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11703   fi
11704 fi
11705 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11706   # Extract the first word of "windmc", so it can be a program name with args.
11707 set dummy windmc; ac_word=$2
11708 echo "$as_me:$LINENO: checking for $ac_word" >&5
11709 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11710 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11711   echo $ECHO_N "(cached) $ECHO_C" >&6
11712 else
11713   case $WINDMC_FOR_TARGET in
11714   [\\/]* | ?:[\\/]*)
11715   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11716   ;;
11717   *)
11718   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11719 for as_dir in $gcc_cv_tool_dirs
11720 do
11721   IFS=$as_save_IFS
11722   test -z "$as_dir" && as_dir=.
11723   for ac_exec_ext in '' $ac_executable_extensions; do
11724   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11725     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11726     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11727     break 2
11728   fi
11729 done
11730 done
11731
11732   ;;
11733 esac
11734 fi
11735 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11736
11737 if test -n "$WINDMC_FOR_TARGET"; then
11738   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11739 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11740 else
11741   echo "$as_me:$LINENO: result: no" >&5
11742 echo "${ECHO_T}no" >&6
11743 fi
11744
11745 fi
11746 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11747
11748
11749 if test -n "$WINDMC_FOR_TARGET"; then
11750   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11751 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11752   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11753 fi
11754
11755 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11756   for ncn_progname in windmc; do
11757     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11758 set dummy ${ncn_progname}; ac_word=$2
11759 echo "$as_me:$LINENO: checking for $ac_word" >&5
11760 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11761 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11762   echo $ECHO_N "(cached) $ECHO_C" >&6
11763 else
11764   if test -n "$WINDMC_FOR_TARGET"; then
11765   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11766 else
11767 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11768 for as_dir in $PATH
11769 do
11770   IFS=$as_save_IFS
11771   test -z "$as_dir" && as_dir=.
11772   for ac_exec_ext in '' $ac_executable_extensions; do
11773   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11774     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11775     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11776     break 2
11777   fi
11778 done
11779 done
11780
11781 fi
11782 fi
11783 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11784 if test -n "$WINDMC_FOR_TARGET"; then
11785   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11786 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11787 else
11788   echo "$as_me:$LINENO: result: no" >&5
11789 echo "${ECHO_T}no" >&6
11790 fi
11791
11792   done
11793 fi
11794
11795 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11796   for ncn_progname in windmc; do
11797     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11798 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11799     if test -x $with_build_time_tools/${ncn_progname}; then
11800       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11801       echo "$as_me:$LINENO: result: yes" >&5
11802 echo "${ECHO_T}yes" >&6
11803       break
11804     else
11805       echo "$as_me:$LINENO: result: no" >&5
11806 echo "${ECHO_T}no" >&6
11807     fi
11808   done
11809 fi
11810
11811 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11812   for ncn_progname in windmc; do
11813     if test -n "$ncn_target_tool_prefix"; then
11814       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11815 set dummy ${ncn_target_tool_prefix}${ncn_progname}; 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_prog_WINDMC_FOR_TARGET+set}" = set; then
11819   echo $ECHO_N "(cached) $ECHO_C" >&6
11820 else
11821   if test -n "$WINDMC_FOR_TARGET"; then
11822   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11823 else
11824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11825 for as_dir in $PATH
11826 do
11827   IFS=$as_save_IFS
11828   test -z "$as_dir" && as_dir=.
11829   for ac_exec_ext in '' $ac_executable_extensions; do
11830   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11831     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11832     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11833     break 2
11834   fi
11835 done
11836 done
11837
11838 fi
11839 fi
11840 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11841 if test -n "$WINDMC_FOR_TARGET"; then
11842   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11843 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11844 else
11845   echo "$as_me:$LINENO: result: no" >&5
11846 echo "${ECHO_T}no" >&6
11847 fi
11848
11849     fi
11850     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11851       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11852 set dummy ${ncn_progname}; ac_word=$2
11853 echo "$as_me:$LINENO: checking for $ac_word" >&5
11854 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11855 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11856   echo $ECHO_N "(cached) $ECHO_C" >&6
11857 else
11858   if test -n "$WINDMC_FOR_TARGET"; then
11859   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11860 else
11861 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11862 for as_dir in $PATH
11863 do
11864   IFS=$as_save_IFS
11865   test -z "$as_dir" && as_dir=.
11866   for ac_exec_ext in '' $ac_executable_extensions; do
11867   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11868     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11869     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11870     break 2
11871   fi
11872 done
11873 done
11874
11875 fi
11876 fi
11877 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11878 if test -n "$WINDMC_FOR_TARGET"; then
11879   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11880 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11881 else
11882   echo "$as_me:$LINENO: result: no" >&5
11883 echo "${ECHO_T}no" >&6
11884 fi
11885
11886     fi
11887     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11888   done
11889 fi
11890
11891 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11892   set dummy windmc
11893   if test $build = $target ; then
11894     WINDMC_FOR_TARGET="$2"
11895   else
11896     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11897   fi
11898 else
11899   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11900 fi
11901
11902 else
11903   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11904 fi
11905
11906
11907 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11908
11909 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11910 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11911 if test "x${build}" != "x${host}" ; then
11912   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11913     # We already found the complete path
11914     ac_dir=`dirname $AR_FOR_TARGET`
11915     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11916 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11917   else
11918     # Canadian cross, just use what we found
11919     echo "$as_me:$LINENO: result: pre-installed" >&5
11920 echo "${ECHO_T}pre-installed" >&6
11921   fi
11922 else
11923   ok=yes
11924   case " ${configdirs} " in
11925     *" binutils "*) ;;
11926     *) ok=no ;;
11927   esac
11928
11929   if test $ok = yes; then
11930     # An in-tree tool is available and we can use it
11931     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11932     echo "$as_me:$LINENO: result: just compiled" >&5
11933 echo "${ECHO_T}just compiled" >&6
11934   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11935     # We already found the complete path
11936     ac_dir=`dirname $AR_FOR_TARGET`
11937     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11938 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11939   elif test "x$target" = "x$host"; then
11940     # We can use an host tool
11941     AR_FOR_TARGET='$(AR)'
11942     echo "$as_me:$LINENO: result: host tool" >&5
11943 echo "${ECHO_T}host tool" >&6
11944   else
11945     # We need a cross tool
11946     echo "$as_me:$LINENO: result: pre-installed" >&5
11947 echo "${ECHO_T}pre-installed" >&6
11948   fi
11949 fi
11950
11951 echo "$as_me:$LINENO: checking where to find the target as" >&5
11952 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11953 if test "x${build}" != "x${host}" ; then
11954   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11955     # We already found the complete path
11956     ac_dir=`dirname $AS_FOR_TARGET`
11957     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11958 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11959   else
11960     # Canadian cross, just use what we found
11961     echo "$as_me:$LINENO: result: pre-installed" >&5
11962 echo "${ECHO_T}pre-installed" >&6
11963   fi
11964 else
11965   ok=yes
11966   case " ${configdirs} " in
11967     *" gas "*) ;;
11968     *) ok=no ;;
11969   esac
11970
11971   if test $ok = yes; then
11972     # An in-tree tool is available and we can use it
11973     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11974     echo "$as_me:$LINENO: result: just compiled" >&5
11975 echo "${ECHO_T}just compiled" >&6
11976   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11977     # We already found the complete path
11978     ac_dir=`dirname $AS_FOR_TARGET`
11979     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11980 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11981   elif test "x$target" = "x$host"; then
11982     # We can use an host tool
11983     AS_FOR_TARGET='$(AS)'
11984     echo "$as_me:$LINENO: result: host tool" >&5
11985 echo "${ECHO_T}host tool" >&6
11986   else
11987     # We need a cross tool
11988     echo "$as_me:$LINENO: result: pre-installed" >&5
11989 echo "${ECHO_T}pre-installed" >&6
11990   fi
11991 fi
11992
11993 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11994 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11995 if test "x${build}" != "x${host}" ; then
11996   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11997     # We already found the complete path
11998     ac_dir=`dirname $CC_FOR_TARGET`
11999     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12000 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12001   else
12002     # Canadian cross, just use what we found
12003     echo "$as_me:$LINENO: result: pre-installed" >&5
12004 echo "${ECHO_T}pre-installed" >&6
12005   fi
12006 else
12007   ok=yes
12008   case " ${configdirs} " in
12009     *" gcc "*) ;;
12010     *) ok=no ;;
12011   esac
12012
12013   if test $ok = yes; then
12014     # An in-tree tool is available and we can use it
12015     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12016     echo "$as_me:$LINENO: result: just compiled" >&5
12017 echo "${ECHO_T}just compiled" >&6
12018   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
12019     # We already found the complete path
12020     ac_dir=`dirname $CC_FOR_TARGET`
12021     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12022 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12023   elif test "x$target" = "x$host"; then
12024     # We can use an host tool
12025     CC_FOR_TARGET='$(CC)'
12026     echo "$as_me:$LINENO: result: host tool" >&5
12027 echo "${ECHO_T}host tool" >&6
12028   else
12029     # We need a cross tool
12030     echo "$as_me:$LINENO: result: pre-installed" >&5
12031 echo "${ECHO_T}pre-installed" >&6
12032   fi
12033 fi
12034
12035 echo "$as_me:$LINENO: checking where to find the target c++" >&5
12036 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
12037 if test "x${build}" != "x${host}" ; then
12038   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12039     # We already found the complete path
12040     ac_dir=`dirname $CXX_FOR_TARGET`
12041     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12042 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12043   else
12044     # Canadian cross, just use what we found
12045     echo "$as_me:$LINENO: result: pre-installed" >&5
12046 echo "${ECHO_T}pre-installed" >&6
12047   fi
12048 else
12049   ok=yes
12050   case " ${configdirs} " in
12051     *" gcc "*) ;;
12052     *) ok=no ;;
12053   esac
12054   case ,${enable_languages}, in
12055     *,c++,*) ;;
12056     *) ok=no ;;
12057   esac
12058   if test $ok = yes; then
12059     # An in-tree tool is available and we can use it
12060     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'
12061     echo "$as_me:$LINENO: result: just compiled" >&5
12062 echo "${ECHO_T}just compiled" >&6
12063   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
12064     # We already found the complete path
12065     ac_dir=`dirname $CXX_FOR_TARGET`
12066     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12067 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12068   elif test "x$target" = "x$host"; then
12069     # We can use an host tool
12070     CXX_FOR_TARGET='$(CXX)'
12071     echo "$as_me:$LINENO: result: host tool" >&5
12072 echo "${ECHO_T}host tool" >&6
12073   else
12074     # We need a cross tool
12075     echo "$as_me:$LINENO: result: pre-installed" >&5
12076 echo "${ECHO_T}pre-installed" >&6
12077   fi
12078 fi
12079
12080 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
12081 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
12082 if test "x${build}" != "x${host}" ; then
12083   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12084     # We already found the complete path
12085     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12086     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12087 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12088   else
12089     # Canadian cross, just use what we found
12090     echo "$as_me:$LINENO: result: pre-installed" >&5
12091 echo "${ECHO_T}pre-installed" >&6
12092   fi
12093 else
12094   ok=yes
12095   case " ${configdirs} " in
12096     *" gcc "*) ;;
12097     *) ok=no ;;
12098   esac
12099   case ,${enable_languages}, in
12100     *,c++,*) ;;
12101     *) ok=no ;;
12102   esac
12103   if test $ok = yes; then
12104     # An in-tree tool is available and we can use it
12105     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'
12106     echo "$as_me:$LINENO: result: just compiled" >&5
12107 echo "${ECHO_T}just compiled" >&6
12108   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
12109     # We already found the complete path
12110     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
12111     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12112 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12113   elif test "x$target" = "x$host"; then
12114     # We can use an host tool
12115     RAW_CXX_FOR_TARGET='$(CXX)'
12116     echo "$as_me:$LINENO: result: host tool" >&5
12117 echo "${ECHO_T}host tool" >&6
12118   else
12119     # We need a cross tool
12120     echo "$as_me:$LINENO: result: pre-installed" >&5
12121 echo "${ECHO_T}pre-installed" >&6
12122   fi
12123 fi
12124
12125 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
12126 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
12127 if test "x${build}" != "x${host}" ; then
12128   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12129     # We already found the complete path
12130     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12131     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12132 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12133   else
12134     # Canadian cross, just use what we found
12135     echo "$as_me:$LINENO: result: pre-installed" >&5
12136 echo "${ECHO_T}pre-installed" >&6
12137   fi
12138 else
12139   ok=yes
12140   case " ${configdirs} " in
12141     *" binutils "*) ;;
12142     *) ok=no ;;
12143   esac
12144
12145   if test $ok = yes; then
12146     # An in-tree tool is available and we can use it
12147     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
12148     echo "$as_me:$LINENO: result: just compiled" >&5
12149 echo "${ECHO_T}just compiled" >&6
12150   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
12151     # We already found the complete path
12152     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
12153     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12154 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12155   elif test "x$target" = "x$host"; then
12156     # We can use an host tool
12157     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
12158     echo "$as_me:$LINENO: result: host tool" >&5
12159 echo "${ECHO_T}host tool" >&6
12160   else
12161     # We need a cross tool
12162     echo "$as_me:$LINENO: result: pre-installed" >&5
12163 echo "${ECHO_T}pre-installed" >&6
12164   fi
12165 fi
12166
12167 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
12168 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
12169 if test "x${build}" != "x${host}" ; then
12170   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12171     # We already found the complete path
12172     ac_dir=`dirname $GCC_FOR_TARGET`
12173     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12174 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12175   else
12176     # Canadian cross, just use what we found
12177     echo "$as_me:$LINENO: result: pre-installed" >&5
12178 echo "${ECHO_T}pre-installed" >&6
12179   fi
12180 else
12181   ok=yes
12182   case " ${configdirs} " in
12183     *" gcc "*) ;;
12184     *) ok=no ;;
12185   esac
12186
12187   if test $ok = yes; then
12188     # An in-tree tool is available and we can use it
12189     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
12190     echo "$as_me:$LINENO: result: just compiled" >&5
12191 echo "${ECHO_T}just compiled" >&6
12192   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
12193     # We already found the complete path
12194     ac_dir=`dirname $GCC_FOR_TARGET`
12195     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12196 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12197   elif test "x$target" = "x$host"; then
12198     # We can use an host tool
12199     GCC_FOR_TARGET='$()'
12200     echo "$as_me:$LINENO: result: host tool" >&5
12201 echo "${ECHO_T}host tool" >&6
12202   else
12203     # We need a cross tool
12204     echo "$as_me:$LINENO: result: pre-installed" >&5
12205 echo "${ECHO_T}pre-installed" >&6
12206   fi
12207 fi
12208
12209 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
12210 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
12211 if test "x${build}" != "x${host}" ; then
12212   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12213     # We already found the complete path
12214     ac_dir=`dirname $GCJ_FOR_TARGET`
12215     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12216 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12217   else
12218     # Canadian cross, just use what we found
12219     echo "$as_me:$LINENO: result: pre-installed" >&5
12220 echo "${ECHO_T}pre-installed" >&6
12221   fi
12222 else
12223   ok=yes
12224   case " ${configdirs} " in
12225     *" gcc "*) ;;
12226     *) ok=no ;;
12227   esac
12228   case ,${enable_languages}, in
12229     *,java,*) ;;
12230     *) ok=no ;;
12231   esac
12232   if test $ok = yes; then
12233     # An in-tree tool is available and we can use it
12234     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
12235     echo "$as_me:$LINENO: result: just compiled" >&5
12236 echo "${ECHO_T}just compiled" >&6
12237   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
12238     # We already found the complete path
12239     ac_dir=`dirname $GCJ_FOR_TARGET`
12240     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12241 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12242   elif test "x$target" = "x$host"; then
12243     # We can use an host tool
12244     GCJ_FOR_TARGET='$(GCJ)'
12245     echo "$as_me:$LINENO: result: host tool" >&5
12246 echo "${ECHO_T}host tool" >&6
12247   else
12248     # We need a cross tool
12249     echo "$as_me:$LINENO: result: pre-installed" >&5
12250 echo "${ECHO_T}pre-installed" >&6
12251   fi
12252 fi
12253
12254 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12255 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12256 if test "x${build}" != "x${host}" ; then
12257   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12258     # We already found the complete path
12259     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12260     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12261 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12262   else
12263     # Canadian cross, just use what we found
12264     echo "$as_me:$LINENO: result: pre-installed" >&5
12265 echo "${ECHO_T}pre-installed" >&6
12266   fi
12267 else
12268   ok=yes
12269   case " ${configdirs} " in
12270     *" gcc "*) ;;
12271     *) ok=no ;;
12272   esac
12273   case ,${enable_languages}, in
12274     *,fortran,*) ;;
12275     *) ok=no ;;
12276   esac
12277   if test $ok = yes; then
12278     # An in-tree tool is available and we can use it
12279     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12280     echo "$as_me:$LINENO: result: just compiled" >&5
12281 echo "${ECHO_T}just compiled" >&6
12282   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12283     # We already found the complete path
12284     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12285     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12286 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12287   elif test "x$target" = "x$host"; then
12288     # We can use an host tool
12289     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12290     echo "$as_me:$LINENO: result: host tool" >&5
12291 echo "${ECHO_T}host tool" >&6
12292   else
12293     # We need a cross tool
12294     echo "$as_me:$LINENO: result: pre-installed" >&5
12295 echo "${ECHO_T}pre-installed" >&6
12296   fi
12297 fi
12298
12299 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12300 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12301 if test "x${build}" != "x${host}" ; then
12302   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12303     # We already found the complete path
12304     ac_dir=`dirname $LD_FOR_TARGET`
12305     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12306 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12307   else
12308     # Canadian cross, just use what we found
12309     echo "$as_me:$LINENO: result: pre-installed" >&5
12310 echo "${ECHO_T}pre-installed" >&6
12311   fi
12312 else
12313   ok=yes
12314   case " ${configdirs} " in
12315     *" ld "*) ;;
12316     *) ok=no ;;
12317   esac
12318
12319   if test $ok = yes; then
12320     # An in-tree tool is available and we can use it
12321     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12322     echo "$as_me:$LINENO: result: just compiled" >&5
12323 echo "${ECHO_T}just compiled" >&6
12324   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12325     # We already found the complete path
12326     ac_dir=`dirname $LD_FOR_TARGET`
12327     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12328 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12329   elif test "x$target" = "x$host"; then
12330     # We can use an host tool
12331     LD_FOR_TARGET='$(LD)'
12332     echo "$as_me:$LINENO: result: host tool" >&5
12333 echo "${ECHO_T}host tool" >&6
12334   else
12335     # We need a cross tool
12336     echo "$as_me:$LINENO: result: pre-installed" >&5
12337 echo "${ECHO_T}pre-installed" >&6
12338   fi
12339 fi
12340
12341 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12342 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12343 if test "x${build}" != "x${host}" ; then
12344   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12345     # We already found the complete path
12346     ac_dir=`dirname $LIPO_FOR_TARGET`
12347     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12348 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12349   else
12350     # Canadian cross, just use what we found
12351     echo "$as_me:$LINENO: result: pre-installed" >&5
12352 echo "${ECHO_T}pre-installed" >&6
12353   fi
12354 else
12355   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12356     # We already found the complete path
12357     ac_dir=`dirname $LIPO_FOR_TARGET`
12358     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12359 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12360   elif test "x$target" = "x$host"; then
12361     # We can use an host tool
12362     LIPO_FOR_TARGET='$(LIPO)'
12363     echo "$as_me:$LINENO: result: host tool" >&5
12364 echo "${ECHO_T}host tool" >&6
12365   else
12366     # We need a cross tool
12367     echo "$as_me:$LINENO: result: pre-installed" >&5
12368 echo "${ECHO_T}pre-installed" >&6
12369   fi
12370 fi
12371
12372 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12373 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12374 if test "x${build}" != "x${host}" ; then
12375   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12376     # We already found the complete path
12377     ac_dir=`dirname $NM_FOR_TARGET`
12378     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12379 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12380   else
12381     # Canadian cross, just use what we found
12382     echo "$as_me:$LINENO: result: pre-installed" >&5
12383 echo "${ECHO_T}pre-installed" >&6
12384   fi
12385 else
12386   ok=yes
12387   case " ${configdirs} " in
12388     *" binutils "*) ;;
12389     *) ok=no ;;
12390   esac
12391
12392   if test $ok = yes; then
12393     # An in-tree tool is available and we can use it
12394     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12395     echo "$as_me:$LINENO: result: just compiled" >&5
12396 echo "${ECHO_T}just compiled" >&6
12397   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12398     # We already found the complete path
12399     ac_dir=`dirname $NM_FOR_TARGET`
12400     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12401 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12402   elif test "x$target" = "x$host"; then
12403     # We can use an host tool
12404     NM_FOR_TARGET='$(NM)'
12405     echo "$as_me:$LINENO: result: host tool" >&5
12406 echo "${ECHO_T}host tool" >&6
12407   else
12408     # We need a cross tool
12409     echo "$as_me:$LINENO: result: pre-installed" >&5
12410 echo "${ECHO_T}pre-installed" >&6
12411   fi
12412 fi
12413
12414 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12415 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12416 if test "x${build}" != "x${host}" ; then
12417   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12418     # We already found the complete path
12419     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12420     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12421 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12422   else
12423     # Canadian cross, just use what we found
12424     echo "$as_me:$LINENO: result: pre-installed" >&5
12425 echo "${ECHO_T}pre-installed" >&6
12426   fi
12427 else
12428   ok=yes
12429   case " ${configdirs} " in
12430     *" binutils "*) ;;
12431     *) ok=no ;;
12432   esac
12433
12434   if test $ok = yes; then
12435     # An in-tree tool is available and we can use it
12436     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12437     echo "$as_me:$LINENO: result: just compiled" >&5
12438 echo "${ECHO_T}just compiled" >&6
12439   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12440     # We already found the complete path
12441     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12442     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12443 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12444   elif test "x$target" = "x$host"; then
12445     # We can use an host tool
12446     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12447     echo "$as_me:$LINENO: result: host tool" >&5
12448 echo "${ECHO_T}host tool" >&6
12449   else
12450     # We need a cross tool
12451     echo "$as_me:$LINENO: result: pre-installed" >&5
12452 echo "${ECHO_T}pre-installed" >&6
12453   fi
12454 fi
12455
12456 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12457 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12458 if test "x${build}" != "x${host}" ; then
12459   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12460     # We already found the complete path
12461     ac_dir=`dirname $RANLIB_FOR_TARGET`
12462     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12463 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12464   else
12465     # Canadian cross, just use what we found
12466     echo "$as_me:$LINENO: result: pre-installed" >&5
12467 echo "${ECHO_T}pre-installed" >&6
12468   fi
12469 else
12470   ok=yes
12471   case " ${configdirs} " in
12472     *" binutils "*) ;;
12473     *) ok=no ;;
12474   esac
12475
12476   if test $ok = yes; then
12477     # An in-tree tool is available and we can use it
12478     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12479     echo "$as_me:$LINENO: result: just compiled" >&5
12480 echo "${ECHO_T}just compiled" >&6
12481   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12482     # We already found the complete path
12483     ac_dir=`dirname $RANLIB_FOR_TARGET`
12484     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12485 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12486   elif test "x$target" = "x$host"; then
12487     # We can use an host tool
12488     RANLIB_FOR_TARGET='$(RANLIB)'
12489     echo "$as_me:$LINENO: result: host tool" >&5
12490 echo "${ECHO_T}host tool" >&6
12491   else
12492     # We need a cross tool
12493     echo "$as_me:$LINENO: result: pre-installed" >&5
12494 echo "${ECHO_T}pre-installed" >&6
12495   fi
12496 fi
12497
12498 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12499 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12500 if test "x${build}" != "x${host}" ; then
12501   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12502     # We already found the complete path
12503     ac_dir=`dirname $STRIP_FOR_TARGET`
12504     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12505 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12506   else
12507     # Canadian cross, just use what we found
12508     echo "$as_me:$LINENO: result: pre-installed" >&5
12509 echo "${ECHO_T}pre-installed" >&6
12510   fi
12511 else
12512   ok=yes
12513   case " ${configdirs} " in
12514     *" binutils "*) ;;
12515     *) ok=no ;;
12516   esac
12517
12518   if test $ok = yes; then
12519     # An in-tree tool is available and we can use it
12520     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12521     echo "$as_me:$LINENO: result: just compiled" >&5
12522 echo "${ECHO_T}just compiled" >&6
12523   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12524     # We already found the complete path
12525     ac_dir=`dirname $STRIP_FOR_TARGET`
12526     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12527 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12528   elif test "x$target" = "x$host"; then
12529     # We can use an host tool
12530     STRIP_FOR_TARGET='$(STRIP)'
12531     echo "$as_me:$LINENO: result: host tool" >&5
12532 echo "${ECHO_T}host tool" >&6
12533   else
12534     # We need a cross tool
12535     echo "$as_me:$LINENO: result: pre-installed" >&5
12536 echo "${ECHO_T}pre-installed" >&6
12537   fi
12538 fi
12539
12540 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12541 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12542 if test "x${build}" != "x${host}" ; then
12543   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12544     # We already found the complete path
12545     ac_dir=`dirname $WINDRES_FOR_TARGET`
12546     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12547 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12548   else
12549     # Canadian cross, just use what we found
12550     echo "$as_me:$LINENO: result: pre-installed" >&5
12551 echo "${ECHO_T}pre-installed" >&6
12552   fi
12553 else
12554   ok=yes
12555   case " ${configdirs} " in
12556     *" binutils "*) ;;
12557     *) ok=no ;;
12558   esac
12559
12560   if test $ok = yes; then
12561     # An in-tree tool is available and we can use it
12562     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12563     echo "$as_me:$LINENO: result: just compiled" >&5
12564 echo "${ECHO_T}just compiled" >&6
12565   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12566     # We already found the complete path
12567     ac_dir=`dirname $WINDRES_FOR_TARGET`
12568     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12569 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12570   elif test "x$target" = "x$host"; then
12571     # We can use an host tool
12572     WINDRES_FOR_TARGET='$(WINDRES)'
12573     echo "$as_me:$LINENO: result: host tool" >&5
12574 echo "${ECHO_T}host tool" >&6
12575   else
12576     # We need a cross tool
12577     echo "$as_me:$LINENO: result: pre-installed" >&5
12578 echo "${ECHO_T}pre-installed" >&6
12579   fi
12580 fi
12581
12582 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12583 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12584 if test "x${build}" != "x${host}" ; then
12585   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12586     # We already found the complete path
12587     ac_dir=`dirname $WINDMC_FOR_TARGET`
12588     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12589 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12590   else
12591     # Canadian cross, just use what we found
12592     echo "$as_me:$LINENO: result: pre-installed" >&5
12593 echo "${ECHO_T}pre-installed" >&6
12594   fi
12595 else
12596   ok=yes
12597   case " ${configdirs} " in
12598     *" binutils "*) ;;
12599     *) ok=no ;;
12600   esac
12601
12602   if test $ok = yes; then
12603     # An in-tree tool is available and we can use it
12604     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12605     echo "$as_me:$LINENO: result: just compiled" >&5
12606 echo "${ECHO_T}just compiled" >&6
12607   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12608     # We already found the complete path
12609     ac_dir=`dirname $WINDMC_FOR_TARGET`
12610     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12611 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12612   elif test "x$target" = "x$host"; then
12613     # We can use an host tool
12614     WINDMC_FOR_TARGET='$(WINDMC)'
12615     echo "$as_me:$LINENO: result: host tool" >&5
12616 echo "${ECHO_T}host tool" >&6
12617   else
12618     # We need a cross tool
12619     echo "$as_me:$LINENO: result: pre-installed" >&5
12620 echo "${ECHO_T}pre-installed" >&6
12621   fi
12622 fi
12623
12624
12625
12626
12627
12628 # Certain tools may need extra flags.
12629 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12630 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12631 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12632
12633 # When building target libraries, except in a Canadian cross, we use
12634 # the same toolchain as the compiler we just built.
12635 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12636 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12637 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12638 if test $host = $build; then
12639   case " $configdirs " in
12640     *" gcc "*)
12641       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12642       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12643       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12644       ;;
12645   esac
12646 fi
12647
12648
12649
12650
12651
12652 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12653 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12654 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12655 if test "${enable_maintainer_mode+set}" = set; then
12656   enableval="$enable_maintainer_mode"
12657   USE_MAINTAINER_MODE=$enableval
12658 else
12659   USE_MAINTAINER_MODE=no
12660 fi;
12661 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12662 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12663
12664
12665 if test "$USE_MAINTAINER_MODE" = yes; then
12666   MAINTAINER_MODE_TRUE=
12667   MAINTAINER_MODE_FALSE='#'
12668 else
12669   MAINTAINER_MODE_TRUE='#'
12670   MAINTAINER_MODE_FALSE=
12671 fi
12672 MAINT=$MAINTAINER_MODE_TRUE
12673
12674 # ---------------------
12675 # GCC bootstrap support
12676 # ---------------------
12677
12678 # Stage specific cflags for build.
12679 stage1_cflags="-g"
12680 case $build in
12681   vax-*-*)
12682     case ${GCC} in
12683       yes) stage1_cflags="-g -Wa,-J" ;;
12684       *) stage1_cflags="-g -J" ;;
12685     esac ;;
12686 esac
12687
12688 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12689 if test "$GCC" = yes; then
12690   saved_CFLAGS="$CFLAGS"
12691
12692   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12693   CFLAGS="$CFLAGS -fkeep-inline-functions"
12694   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12695 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12696   cat >conftest.$ac_ext <<_ACEOF
12697 /* confdefs.h.  */
12698 _ACEOF
12699 cat confdefs.h >>conftest.$ac_ext
12700 cat >>conftest.$ac_ext <<_ACEOF
12701 /* end confdefs.h.  */
12702
12703 #if (__GNUC__ < 3) \
12704     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12705                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12706 #error http://gcc.gnu.org/PR29382
12707 #endif
12708
12709 int
12710 main ()
12711 {
12712
12713   ;
12714   return 0;
12715 }
12716 _ACEOF
12717 rm -f conftest.$ac_objext
12718 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12719   (eval $ac_compile) 2>conftest.er1
12720   ac_status=$?
12721   grep -v '^ *+' conftest.er1 >conftest.err
12722   rm -f conftest.er1
12723   cat conftest.err >&5
12724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12725   (exit $ac_status); } &&
12726          { ac_try='test -z "$ac_c_werror_flag"
12727                          || test ! -s conftest.err'
12728   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12729   (eval $ac_try) 2>&5
12730   ac_status=$?
12731   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12732   (exit $ac_status); }; } &&
12733          { ac_try='test -s conftest.$ac_objext'
12734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12735   (eval $ac_try) 2>&5
12736   ac_status=$?
12737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12738   (exit $ac_status); }; }; then
12739   echo "$as_me:$LINENO: result: yes" >&5
12740 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12741 else
12742   echo "$as_me: failed program was:" >&5
12743 sed 's/^/| /' conftest.$ac_ext >&5
12744
12745 echo "$as_me:$LINENO: result: no" >&5
12746 echo "${ECHO_T}no" >&6
12747 fi
12748 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12749
12750   CFLAGS="$saved_CFLAGS"
12751 fi
12752
12753
12754
12755 # Enable --enable-checking in stage1 of the compiler.
12756 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12757 if test "${enable_stage1_checking+set}" = set; then
12758   enableval="$enable_stage1_checking"
12759   stage1_checking=--enable-checking=${enable_stage1_checking}
12760 else
12761   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12762   stage1_checking=--enable-checking=yes,types
12763 else
12764   stage1_checking=--enable-checking=$enable_checking,types
12765 fi
12766 fi;
12767
12768
12769 # Enable -Werror in bootstrap stage2 and later.
12770 # Check whether --enable-werror or --disable-werror was given.
12771 if test "${enable_werror+set}" = set; then
12772   enableval="$enable_werror"
12773
12774 else
12775   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12776   enable_werror=yes
12777 else
12778   enable_werror=no
12779 fi
12780 fi;
12781 case ${enable_werror} in
12782   yes) stage2_werror_flag="--enable-werror-always" ;;
12783   *) stage2_werror_flag="" ;;
12784 esac
12785
12786
12787 # Flags needed to enable html installing and building
12788
12789 # Check whether --with-datarootdir or --without-datarootdir was given.
12790 if test "${with_datarootdir+set}" = set; then
12791   withval="$with_datarootdir"
12792   datarootdir="\${prefix}/${withval}"
12793 else
12794   datarootdir="\${prefix}/share"
12795 fi;
12796
12797
12798 # Check whether --with-docdir or --without-docdir was given.
12799 if test "${with_docdir+set}" = set; then
12800   withval="$with_docdir"
12801   docdir="\${prefix}/${withval}"
12802 else
12803   docdir="\${datarootdir}/doc"
12804 fi;
12805
12806
12807 # Check whether --with-pdfdir or --without-pdfdir was given.
12808 if test "${with_pdfdir+set}" = set; then
12809   withval="$with_pdfdir"
12810   pdfdir="\${prefix}/${withval}"
12811 else
12812   pdfdir="\${docdir}"
12813 fi;
12814
12815
12816 # Check whether --with-htmldir or --without-htmldir was given.
12817 if test "${with_htmldir+set}" = set; then
12818   withval="$with_htmldir"
12819   htmldir="\${prefix}/${withval}"
12820 else
12821   htmldir="\${docdir}"
12822 fi;
12823
12824
12825
12826
12827
12828
12829           ac_config_files="$ac_config_files Makefile"
12830 cat >confcache <<\_ACEOF
12831 # This file is a shell script that caches the results of configure
12832 # tests run on this system so they can be shared between configure
12833 # scripts and configure runs, see configure's option --config-cache.
12834 # It is not useful on other systems.  If it contains results you don't
12835 # want to keep, you may remove or edit it.
12836 #
12837 # config.status only pays attention to the cache file if you give it
12838 # the --recheck option to rerun configure.
12839 #
12840 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12841 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12842 # following values.
12843
12844 _ACEOF
12845
12846 # The following way of writing the cache mishandles newlines in values,
12847 # but we know of no workaround that is simple, portable, and efficient.
12848 # So, don't put newlines in cache variables' values.
12849 # Ultrix sh set writes to stderr and can't be redirected directly,
12850 # and sets the high bit in the cache file unless we assign to the vars.
12851 {
12852   (set) 2>&1 |
12853     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12854     *ac_space=\ *)
12855       # `set' does not quote correctly, so add quotes (double-quote
12856       # substitution turns \\\\ into \\, and sed turns \\ into \).
12857       sed -n \
12858         "s/'/'\\\\''/g;
12859           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12860       ;;
12861     *)
12862       # `set' quotes correctly as required by POSIX, so do not add quotes.
12863       sed -n \
12864         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12865       ;;
12866     esac;
12867 } |
12868   sed '
12869      t clear
12870      : clear
12871      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12872      t end
12873      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12874      : end' >>confcache
12875 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12876   if test -w $cache_file; then
12877     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12878     cat confcache >$cache_file
12879   else
12880     echo "not updating unwritable cache $cache_file"
12881   fi
12882 fi
12883 rm -f confcache
12884
12885 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12886 # Let make expand exec_prefix.
12887 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12888
12889 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12890 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12891 # trailing colons and then remove the whole line if VPATH becomes empty
12892 # (actually we leave an empty line to preserve line numbers).
12893 if test "x$srcdir" = x.; then
12894   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12895 s/:*\$(srcdir):*/:/;
12896 s/:*\${srcdir}:*/:/;
12897 s/:*@srcdir@:*/:/;
12898 s/^\([^=]*=[     ]*\):*/\1/;
12899 s/:*$//;
12900 s/^[^=]*=[       ]*$//;
12901 }'
12902 fi
12903
12904 # Transform confdefs.h into DEFS.
12905 # Protect against shell expansion while executing Makefile rules.
12906 # Protect against Makefile macro expansion.
12907 #
12908 # If the first sed substitution is executed (which looks for macros that
12909 # take arguments), then we branch to the quote section.  Otherwise,
12910 # look for a macro that doesn't take arguments.
12911 cat >confdef2opt.sed <<\_ACEOF
12912 t clear
12913 : clear
12914 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12915 t quote
12916 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12917 t quote
12918 d
12919 : quote
12920 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12921 s,\[,\\&,g
12922 s,\],\\&,g
12923 s,\$,$$,g
12924 p
12925 _ACEOF
12926 # We use echo to avoid assuming a particular line-breaking character.
12927 # The extra dot is to prevent the shell from consuming trailing
12928 # line-breaks from the sub-command output.  A line-break within
12929 # single-quotes doesn't work because, if this script is created in a
12930 # platform that uses two characters for line-breaks (e.g., DOS), tr
12931 # would break.
12932 ac_LF_and_DOT=`echo; echo .`
12933 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12934 rm -f confdef2opt.sed
12935
12936
12937 ac_libobjs=
12938 ac_ltlibobjs=
12939 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12940   # 1. Remove the extension, and $U if already installed.
12941   ac_i=`echo "$ac_i" |
12942          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12943   # 2. Add them.
12944   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12945   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12946 done
12947 LIBOBJS=$ac_libobjs
12948
12949 LTLIBOBJS=$ac_ltlibobjs
12950
12951
12952
12953 : ${CONFIG_STATUS=./config.status}
12954 ac_clean_files_save=$ac_clean_files
12955 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12956 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12957 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12958 cat >$CONFIG_STATUS <<_ACEOF
12959 #! $SHELL
12960 # Generated by $as_me.
12961 # Run this file to recreate the current configuration.
12962 # Compiler output produced by configure, useful for debugging
12963 # configure, is in config.log if it exists.
12964
12965 debug=false
12966 ac_cs_recheck=false
12967 ac_cs_silent=false
12968 SHELL=\${CONFIG_SHELL-$SHELL}
12969 _ACEOF
12970
12971 cat >>$CONFIG_STATUS <<\_ACEOF
12972 ## --------------------- ##
12973 ## M4sh Initialization.  ##
12974 ## --------------------- ##
12975
12976 # Be Bourne compatible
12977 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12978   emulate sh
12979   NULLCMD=:
12980   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12981   # is contrary to our usage.  Disable this feature.
12982   alias -g '${1+"$@"}'='"$@"'
12983 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12984   set -o posix
12985 fi
12986 DUALCASE=1; export DUALCASE # for MKS sh
12987
12988 # Support unset when possible.
12989 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12990   as_unset=unset
12991 else
12992   as_unset=false
12993 fi
12994
12995
12996 # Work around bugs in pre-3.0 UWIN ksh.
12997 $as_unset ENV MAIL MAILPATH
12998 PS1='$ '
12999 PS2='> '
13000 PS4='+ '
13001
13002 # NLS nuisances.
13003 for as_var in \
13004   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
13005   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
13006   LC_TELEPHONE LC_TIME
13007 do
13008   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
13009     eval $as_var=C; export $as_var
13010   else
13011     $as_unset $as_var
13012   fi
13013 done
13014
13015 # Required to use basename.
13016 if expr a : '\(a\)' >/dev/null 2>&1; then
13017   as_expr=expr
13018 else
13019   as_expr=false
13020 fi
13021
13022 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
13023   as_basename=basename
13024 else
13025   as_basename=false
13026 fi
13027
13028
13029 # Name of the executable.
13030 as_me=`$as_basename "$0" ||
13031 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
13032          X"$0" : 'X\(//\)$' \| \
13033          X"$0" : 'X\(/\)$' \| \
13034          .     : '\(.\)' 2>/dev/null ||
13035 echo X/"$0" |
13036     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
13037           /^X\/\(\/\/\)$/{ s//\1/; q; }
13038           /^X\/\(\/\).*/{ s//\1/; q; }
13039           s/.*/./; q'`
13040
13041
13042 # PATH needs CR, and LINENO needs CR and PATH.
13043 # Avoid depending upon Character Ranges.
13044 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
13045 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
13046 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
13047 as_cr_digits='0123456789'
13048 as_cr_alnum=$as_cr_Letters$as_cr_digits
13049
13050 # The user is always right.
13051 if test "${PATH_SEPARATOR+set}" != set; then
13052   echo "#! /bin/sh" >conf$$.sh
13053   echo  "exit 0"   >>conf$$.sh
13054   chmod +x conf$$.sh
13055   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
13056     PATH_SEPARATOR=';'
13057   else
13058     PATH_SEPARATOR=:
13059   fi
13060   rm -f conf$$.sh
13061 fi
13062
13063
13064   as_lineno_1=$LINENO
13065   as_lineno_2=$LINENO
13066   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13067   test "x$as_lineno_1" != "x$as_lineno_2" &&
13068   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
13069   # Find who we are.  Look in the path if we contain no path at all
13070   # relative or not.
13071   case $0 in
13072     *[\\/]* ) as_myself=$0 ;;
13073     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13074 for as_dir in $PATH
13075 do
13076   IFS=$as_save_IFS
13077   test -z "$as_dir" && as_dir=.
13078   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
13079 done
13080
13081        ;;
13082   esac
13083   # We did not find ourselves, most probably we were run as `sh COMMAND'
13084   # in which case we are not to be found in the path.
13085   if test "x$as_myself" = x; then
13086     as_myself=$0
13087   fi
13088   if test ! -f "$as_myself"; then
13089     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
13090 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
13091    { (exit 1); exit 1; }; }
13092   fi
13093   case $CONFIG_SHELL in
13094   '')
13095     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
13096 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
13097 do
13098   IFS=$as_save_IFS
13099   test -z "$as_dir" && as_dir=.
13100   for as_base in sh bash ksh sh5; do
13101          case $as_dir in
13102          /*)
13103            if ("$as_dir/$as_base" -c '
13104   as_lineno_1=$LINENO
13105   as_lineno_2=$LINENO
13106   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
13107   test "x$as_lineno_1" != "x$as_lineno_2" &&
13108   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
13109              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
13110              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
13111              CONFIG_SHELL=$as_dir/$as_base
13112              export CONFIG_SHELL
13113              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
13114            fi;;
13115          esac
13116        done
13117 done
13118 ;;
13119   esac
13120
13121   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
13122   # uniformly replaced by the line number.  The first 'sed' inserts a
13123   # line-number line before each line; the second 'sed' does the real
13124   # work.  The second script uses 'N' to pair each line-number line
13125   # with the numbered line, and appends trailing '-' during
13126   # substitution so that $LINENO is not a special case at line end.
13127   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
13128   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
13129   sed '=' <$as_myself |
13130     sed '
13131       N
13132       s,$,-,
13133       : loop
13134       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
13135       t loop
13136       s,-$,,
13137       s,^['$as_cr_digits']*\n,,
13138     ' >$as_me.lineno &&
13139   chmod +x $as_me.lineno ||
13140     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
13141 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
13142    { (exit 1); exit 1; }; }
13143
13144   # Don't try to exec as it changes $[0], causing all sort of problems
13145   # (the dirname of $[0] is not the place where we might find the
13146   # original and so on.  Autoconf is especially sensible to this).
13147   . ./$as_me.lineno
13148   # Exit status is that of the last command.
13149   exit
13150 }
13151
13152
13153 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
13154   *c*,-n*) ECHO_N= ECHO_C='
13155 ' ECHO_T='      ' ;;
13156   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
13157   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
13158 esac
13159
13160 if expr a : '\(a\)' >/dev/null 2>&1; then
13161   as_expr=expr
13162 else
13163   as_expr=false
13164 fi
13165
13166 rm -f conf$$ conf$$.exe conf$$.file
13167 echo >conf$$.file
13168 if ln -s conf$$.file conf$$ 2>/dev/null; then
13169   # We could just check for DJGPP; but this test a) works b) is more generic
13170   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
13171   if test -f conf$$.exe; then
13172     # Don't use ln at all; we don't have any links
13173     as_ln_s='cp -p'
13174   else
13175     as_ln_s='ln -s'
13176   fi
13177 elif ln conf$$.file conf$$ 2>/dev/null; then
13178   as_ln_s=ln
13179 else
13180   as_ln_s='cp -p'
13181 fi
13182 rm -f conf$$ conf$$.exe conf$$.file
13183
13184 if mkdir -p . 2>/dev/null; then
13185   as_mkdir_p=:
13186 else
13187   test -d ./-p && rmdir ./-p
13188   as_mkdir_p=false
13189 fi
13190
13191 as_executable_p="test -f"
13192
13193 # Sed expression to map a string onto a valid CPP name.
13194 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
13195
13196 # Sed expression to map a string onto a valid variable name.
13197 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
13198
13199
13200 # IFS
13201 # We need space, tab and new line, in precisely that order.
13202 as_nl='
13203 '
13204 IFS="   $as_nl"
13205
13206 # CDPATH.
13207 $as_unset CDPATH
13208
13209 exec 6>&1
13210
13211 # Open the log real soon, to keep \$[0] and so on meaningful, and to
13212 # report actual input values of CONFIG_FILES etc. instead of their
13213 # values after options handling.  Logging --version etc. is OK.
13214 exec 5>>config.log
13215 {
13216   echo
13217   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
13218 ## Running $as_me. ##
13219 _ASBOX
13220 } >&5
13221 cat >&5 <<_CSEOF
13222
13223 This file was extended by $as_me, which was
13224 generated by GNU Autoconf 2.59.  Invocation command line was
13225
13226   CONFIG_FILES    = $CONFIG_FILES
13227   CONFIG_HEADERS  = $CONFIG_HEADERS
13228   CONFIG_LINKS    = $CONFIG_LINKS
13229   CONFIG_COMMANDS = $CONFIG_COMMANDS
13230   $ $0 $@
13231
13232 _CSEOF
13233 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
13234 echo >&5
13235 _ACEOF
13236
13237 # Files that config.status was made for.
13238 if test -n "$ac_config_files"; then
13239   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
13240 fi
13241
13242 if test -n "$ac_config_headers"; then
13243   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
13244 fi
13245
13246 if test -n "$ac_config_links"; then
13247   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13248 fi
13249
13250 if test -n "$ac_config_commands"; then
13251   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13252 fi
13253
13254 cat >>$CONFIG_STATUS <<\_ACEOF
13255
13256 ac_cs_usage="\
13257 \`$as_me' instantiates files from templates according to the
13258 current configuration.
13259
13260 Usage: $0 [OPTIONS] [FILE]...
13261
13262   -h, --help       print this help, then exit
13263   -V, --version    print version number, then exit
13264   -q, --quiet      do not print progress messages
13265   -d, --debug      don't remove temporary files
13266       --recheck    update $as_me by reconfiguring in the same conditions
13267   --file=FILE[:TEMPLATE]
13268                    instantiate the configuration file FILE
13269
13270 Configuration files:
13271 $config_files
13272
13273 Report bugs to <bug-autoconf@gnu.org>."
13274 _ACEOF
13275
13276 cat >>$CONFIG_STATUS <<_ACEOF
13277 ac_cs_version="\\
13278 config.status
13279 configured by $0, generated by GNU Autoconf 2.59,
13280   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13281
13282 Copyright (C) 2003 Free Software Foundation, Inc.
13283 This config.status script is free software; the Free Software Foundation
13284 gives unlimited permission to copy, distribute and modify it."
13285 srcdir=$srcdir
13286 INSTALL="$INSTALL"
13287 _ACEOF
13288
13289 cat >>$CONFIG_STATUS <<\_ACEOF
13290 # If no file are specified by the user, then we need to provide default
13291 # value.  By we need to know if files were specified by the user.
13292 ac_need_defaults=:
13293 while test $# != 0
13294 do
13295   case $1 in
13296   --*=*)
13297     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13298     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13299     ac_shift=:
13300     ;;
13301   -*)
13302     ac_option=$1
13303     ac_optarg=$2
13304     ac_shift=shift
13305     ;;
13306   *) # This is not an option, so the user has probably given explicit
13307      # arguments.
13308      ac_option=$1
13309      ac_need_defaults=false;;
13310   esac
13311
13312   case $ac_option in
13313   # Handling of the options.
13314 _ACEOF
13315 cat >>$CONFIG_STATUS <<\_ACEOF
13316   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13317     ac_cs_recheck=: ;;
13318   --version | --vers* | -V )
13319     echo "$ac_cs_version"; exit 0 ;;
13320   --he | --h)
13321     # Conflict between --help and --header
13322     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13323 Try \`$0 --help' for more information." >&5
13324 echo "$as_me: error: ambiguous option: $1
13325 Try \`$0 --help' for more information." >&2;}
13326    { (exit 1); exit 1; }; };;
13327   --help | --hel | -h )
13328     echo "$ac_cs_usage"; exit 0 ;;
13329   --debug | --d* | -d )
13330     debug=: ;;
13331   --file | --fil | --fi | --f )
13332     $ac_shift
13333     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13334     ac_need_defaults=false;;
13335   --header | --heade | --head | --hea )
13336     $ac_shift
13337     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13338     ac_need_defaults=false;;
13339   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13340   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13341     ac_cs_silent=: ;;
13342
13343   # This is an error.
13344   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13345 Try \`$0 --help' for more information." >&5
13346 echo "$as_me: error: unrecognized option: $1
13347 Try \`$0 --help' for more information." >&2;}
13348    { (exit 1); exit 1; }; } ;;
13349
13350   *) ac_config_targets="$ac_config_targets $1" ;;
13351
13352   esac
13353   shift
13354 done
13355
13356 ac_configure_extra_args=
13357
13358 if $ac_cs_silent; then
13359   exec 6>/dev/null
13360   ac_configure_extra_args="$ac_configure_extra_args --silent"
13361 fi
13362
13363 _ACEOF
13364 cat >>$CONFIG_STATUS <<_ACEOF
13365 if \$ac_cs_recheck; then
13366   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13367   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13368 fi
13369
13370 _ACEOF
13371
13372
13373
13374
13375
13376 cat >>$CONFIG_STATUS <<\_ACEOF
13377 for ac_config_target in $ac_config_targets
13378 do
13379   case "$ac_config_target" in
13380   # Handling of arguments.
13381   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13382   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13383 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13384    { (exit 1); exit 1; }; };;
13385   esac
13386 done
13387
13388 # If the user did not use the arguments to specify the items to instantiate,
13389 # then the envvar interface is used.  Set only those that are not.
13390 # We use the long form for the default assignment because of an extremely
13391 # bizarre bug on SunOS 4.1.3.
13392 if $ac_need_defaults; then
13393   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13394 fi
13395
13396 # Have a temporary directory for convenience.  Make it in the build tree
13397 # simply because there is no reason to put it here, and in addition,
13398 # creating and moving files from /tmp can sometimes cause problems.
13399 # Create a temporary directory, and hook for its removal unless debugging.
13400 $debug ||
13401 {
13402   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13403   trap '{ (exit 1); exit 1; }' 1 2 13 15
13404 }
13405
13406 # Create a (secure) tmp directory for tmp files.
13407
13408 {
13409   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13410   test -n "$tmp" && test -d "$tmp"
13411 }  ||
13412 {
13413   tmp=./confstat$$-$RANDOM
13414   (umask 077 && mkdir $tmp)
13415 } ||
13416 {
13417    echo "$me: cannot create a temporary directory in ." >&2
13418    { (exit 1); exit 1; }
13419 }
13420
13421 _ACEOF
13422
13423 cat >>$CONFIG_STATUS <<_ACEOF
13424
13425 #
13426 # CONFIG_FILES section.
13427 #
13428
13429 # No need to generate the scripts if there are no CONFIG_FILES.
13430 # This happens for instance when ./config.status config.h
13431 if test -n "\$CONFIG_FILES"; then
13432   # Protect against being on the right side of a sed subst in config.status.
13433   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13434    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13435 s,@SHELL@,$SHELL,;t t
13436 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13437 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13438 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13439 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13440 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13441 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13442 s,@exec_prefix@,$exec_prefix,;t t
13443 s,@prefix@,$prefix,;t t
13444 s,@program_transform_name@,$program_transform_name,;t t
13445 s,@bindir@,$bindir,;t t
13446 s,@sbindir@,$sbindir,;t t
13447 s,@libexecdir@,$libexecdir,;t t
13448 s,@datadir@,$datadir,;t t
13449 s,@sysconfdir@,$sysconfdir,;t t
13450 s,@sharedstatedir@,$sharedstatedir,;t t
13451 s,@localstatedir@,$localstatedir,;t t
13452 s,@libdir@,$libdir,;t t
13453 s,@includedir@,$includedir,;t t
13454 s,@oldincludedir@,$oldincludedir,;t t
13455 s,@infodir@,$infodir,;t t
13456 s,@mandir@,$mandir,;t t
13457 s,@build_alias@,$build_alias,;t t
13458 s,@host_alias@,$host_alias,;t t
13459 s,@target_alias@,$target_alias,;t t
13460 s,@DEFS@,$DEFS,;t t
13461 s,@ECHO_C@,$ECHO_C,;t t
13462 s,@ECHO_N@,$ECHO_N,;t t
13463 s,@ECHO_T@,$ECHO_T,;t t
13464 s,@LIBS@,$LIBS,;t t
13465 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13466 s,@build@,$build,;t t
13467 s,@build_cpu@,$build_cpu,;t t
13468 s,@build_vendor@,$build_vendor,;t t
13469 s,@build_os@,$build_os,;t t
13470 s,@build_noncanonical@,$build_noncanonical,;t t
13471 s,@host_noncanonical@,$host_noncanonical,;t t
13472 s,@target_noncanonical@,$target_noncanonical,;t t
13473 s,@host@,$host,;t t
13474 s,@host_cpu@,$host_cpu,;t t
13475 s,@host_vendor@,$host_vendor,;t t
13476 s,@host_os@,$host_os,;t t
13477 s,@target@,$target,;t t
13478 s,@target_cpu@,$target_cpu,;t t
13479 s,@target_vendor@,$target_vendor,;t t
13480 s,@target_os@,$target_os,;t t
13481 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13482 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13483 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13484 s,@LN@,$LN,;t t
13485 s,@LN_S@,$LN_S,;t t
13486 s,@build_libsubdir@,$build_libsubdir,;t t
13487 s,@build_subdir@,$build_subdir,;t t
13488 s,@host_subdir@,$host_subdir,;t t
13489 s,@target_subdir@,$target_subdir,;t t
13490 s,@CC@,$CC,;t t
13491 s,@CFLAGS@,$CFLAGS,;t t
13492 s,@LDFLAGS@,$LDFLAGS,;t t
13493 s,@CPPFLAGS@,$CPPFLAGS,;t t
13494 s,@ac_ct_CC@,$ac_ct_CC,;t t
13495 s,@EXEEXT@,$EXEEXT,;t t
13496 s,@OBJEXT@,$OBJEXT,;t t
13497 s,@CXX@,$CXX,;t t
13498 s,@CXXFLAGS@,$CXXFLAGS,;t t
13499 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13500 s,@GNATBIND@,$GNATBIND,;t t
13501 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13502 s,@GNATMAKE@,$GNATMAKE,;t t
13503 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13504 s,@do_compare@,$do_compare,;t t
13505 s,@gmplibs@,$gmplibs,;t t
13506 s,@gmpinc@,$gmpinc,;t t
13507 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13508 s,@extra_mpc_gmp_configure_flags@,$extra_mpc_gmp_configure_flags,;t t
13509 s,@extra_mpc_mpfr_configure_flags@,$extra_mpc_mpfr_configure_flags,;t t
13510 s,@ppllibs@,$ppllibs,;t t
13511 s,@pplinc@,$pplinc,;t t
13512 s,@clooglibs@,$clooglibs,;t t
13513 s,@clooginc@,$clooginc,;t t
13514 s,@stage1_languages@,$stage1_languages,;t t
13515 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13516 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13517 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13518 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13519 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13520 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13521 s,@tooldir@,$tooldir,;t t
13522 s,@build_tooldir@,$build_tooldir,;t t
13523 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13524 s,@GDB_TK@,$GDB_TK,;t t
13525 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13526 s,@build_configargs@,$build_configargs,;t t
13527 s,@build_configdirs@,$build_configdirs,;t t
13528 s,@host_configargs@,$host_configargs,;t t
13529 s,@configdirs@,$configdirs,;t t
13530 s,@target_configargs@,$target_configargs,;t t
13531 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13532 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13533 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13534 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13535 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13536 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13537 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13538 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13539 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13540 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13541 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13542 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13543 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13544 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13545 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13546 s,@config_shell@,$config_shell,;t t
13547 s,@YACC@,$YACC,;t t
13548 s,@BISON@,$BISON,;t t
13549 s,@M4@,$M4,;t t
13550 s,@LEX@,$LEX,;t t
13551 s,@FLEX@,$FLEX,;t t
13552 s,@MAKEINFO@,$MAKEINFO,;t t
13553 s,@EXPECT@,$EXPECT,;t t
13554 s,@RUNTEST@,$RUNTEST,;t t
13555 s,@AR@,$AR,;t t
13556 s,@AS@,$AS,;t t
13557 s,@DLLTOOL@,$DLLTOOL,;t t
13558 s,@LD@,$LD,;t t
13559 s,@LIPO@,$LIPO,;t t
13560 s,@NM@,$NM,;t t
13561 s,@RANLIB@,$RANLIB,;t t
13562 s,@STRIP@,$STRIP,;t t
13563 s,@WINDRES@,$WINDRES,;t t
13564 s,@WINDMC@,$WINDMC,;t t
13565 s,@OBJCOPY@,$OBJCOPY,;t t
13566 s,@OBJDUMP@,$OBJDUMP,;t t
13567 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13568 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13569 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13570 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13571 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13572 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13573 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13574 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13575 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13576 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13577 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13578 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13579 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13580 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13581 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13582 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13583 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13584 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13585 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13586 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13587 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13588 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13589 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13590 s,@MAINT@,$MAINT,;t t
13591 s,@stage1_cflags@,$stage1_cflags,;t t
13592 s,@stage1_checking@,$stage1_checking,;t t
13593 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13594 s,@datarootdir@,$datarootdir,;t t
13595 s,@docdir@,$docdir,;t t
13596 s,@pdfdir@,$pdfdir,;t t
13597 s,@htmldir@,$htmldir,;t t
13598 s,@LIBOBJS@,$LIBOBJS,;t t
13599 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13600 /@serialization_dependencies@/r $serialization_dependencies
13601 s,@serialization_dependencies@,,;t t
13602 /@host_makefile_frag@/r $host_makefile_frag
13603 s,@host_makefile_frag@,,;t t
13604 /@target_makefile_frag@/r $target_makefile_frag
13605 s,@target_makefile_frag@,,;t t
13606 /@alphaieee_frag@/r $alphaieee_frag
13607 s,@alphaieee_frag@,,;t t
13608 /@ospace_frag@/r $ospace_frag
13609 s,@ospace_frag@,,;t t
13610 CEOF
13611
13612 _ACEOF
13613
13614   cat >>$CONFIG_STATUS <<\_ACEOF
13615   # Split the substitutions into bite-sized pieces for seds with
13616   # small command number limits, like on Digital OSF/1 and HP-UX.
13617   ac_max_sed_lines=48
13618   ac_sed_frag=1 # Number of current file.
13619   ac_beg=1 # First line for current file.
13620   ac_end=$ac_max_sed_lines # Line after last line for current file.
13621   ac_more_lines=:
13622   ac_sed_cmds=
13623   while $ac_more_lines; do
13624     if test $ac_beg -gt 1; then
13625       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13626     else
13627       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13628     fi
13629     if test ! -s $tmp/subs.frag; then
13630       ac_more_lines=false
13631     else
13632       # The purpose of the label and of the branching condition is to
13633       # speed up the sed processing (if there are no `@' at all, there
13634       # is no need to browse any of the substitutions).
13635       # These are the two extra sed commands mentioned above.
13636       (echo ':t
13637   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13638       if test -z "$ac_sed_cmds"; then
13639         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13640       else
13641         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13642       fi
13643       ac_sed_frag=`expr $ac_sed_frag + 1`
13644       ac_beg=$ac_end
13645       ac_end=`expr $ac_end + $ac_max_sed_lines`
13646     fi
13647   done
13648   if test -z "$ac_sed_cmds"; then
13649     ac_sed_cmds=cat
13650   fi
13651 fi # test -n "$CONFIG_FILES"
13652
13653 _ACEOF
13654 cat >>$CONFIG_STATUS <<\_ACEOF
13655 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13656   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13657   case $ac_file in
13658   - | *:- | *:-:* ) # input from stdin
13659         cat >$tmp/stdin
13660         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13661         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13662   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13663         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13664   * )   ac_file_in=$ac_file.in ;;
13665   esac
13666
13667   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13668   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13669 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13670          X"$ac_file" : 'X\(//\)[^/]' \| \
13671          X"$ac_file" : 'X\(//\)$' \| \
13672          X"$ac_file" : 'X\(/\)' \| \
13673          .     : '\(.\)' 2>/dev/null ||
13674 echo X"$ac_file" |
13675     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13676           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13677           /^X\(\/\/\)$/{ s//\1/; q; }
13678           /^X\(\/\).*/{ s//\1/; q; }
13679           s/.*/./; q'`
13680   { if $as_mkdir_p; then
13681     mkdir -p "$ac_dir"
13682   else
13683     as_dir="$ac_dir"
13684     as_dirs=
13685     while test ! -d "$as_dir"; do
13686       as_dirs="$as_dir $as_dirs"
13687       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13688 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13689          X"$as_dir" : 'X\(//\)[^/]' \| \
13690          X"$as_dir" : 'X\(//\)$' \| \
13691          X"$as_dir" : 'X\(/\)' \| \
13692          .     : '\(.\)' 2>/dev/null ||
13693 echo X"$as_dir" |
13694     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13695           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13696           /^X\(\/\/\)$/{ s//\1/; q; }
13697           /^X\(\/\).*/{ s//\1/; q; }
13698           s/.*/./; q'`
13699     done
13700     test ! -n "$as_dirs" || mkdir $as_dirs
13701   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13702 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13703    { (exit 1); exit 1; }; }; }
13704
13705   ac_builddir=.
13706
13707 if test "$ac_dir" != .; then
13708   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13709   # A "../" for each directory in $ac_dir_suffix.
13710   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13711 else
13712   ac_dir_suffix= ac_top_builddir=
13713 fi
13714
13715 case $srcdir in
13716   .)  # No --srcdir option.  We are building in place.
13717     ac_srcdir=.
13718     if test -z "$ac_top_builddir"; then
13719        ac_top_srcdir=.
13720     else
13721        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13722     fi ;;
13723   [\\/]* | ?:[\\/]* )  # Absolute path.
13724     ac_srcdir=$srcdir$ac_dir_suffix;
13725     ac_top_srcdir=$srcdir ;;
13726   *) # Relative path.
13727     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13728     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13729 esac
13730
13731 # Do not use `cd foo && pwd` to compute absolute paths, because
13732 # the directories may not exist.
13733 case `pwd` in
13734 .) ac_abs_builddir="$ac_dir";;
13735 *)
13736   case "$ac_dir" in
13737   .) ac_abs_builddir=`pwd`;;
13738   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13739   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13740   esac;;
13741 esac
13742 case $ac_abs_builddir in
13743 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13744 *)
13745   case ${ac_top_builddir}. in
13746   .) ac_abs_top_builddir=$ac_abs_builddir;;
13747   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13748   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13749   esac;;
13750 esac
13751 case $ac_abs_builddir in
13752 .) ac_abs_srcdir=$ac_srcdir;;
13753 *)
13754   case $ac_srcdir in
13755   .) ac_abs_srcdir=$ac_abs_builddir;;
13756   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13757   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13758   esac;;
13759 esac
13760 case $ac_abs_builddir in
13761 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13762 *)
13763   case $ac_top_srcdir in
13764   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13765   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13766   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13767   esac;;
13768 esac
13769
13770
13771   case $INSTALL in
13772   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13773   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13774   esac
13775
13776   if test x"$ac_file" != x-; then
13777     { echo "$as_me:$LINENO: creating $ac_file" >&5
13778 echo "$as_me: creating $ac_file" >&6;}
13779     rm -f "$ac_file"
13780   fi
13781   # Let's still pretend it is `configure' which instantiates (i.e., don't
13782   # use $as_me), people would be surprised to read:
13783   #    /* config.h.  Generated by config.status.  */
13784   if test x"$ac_file" = x-; then
13785     configure_input=
13786   else
13787     configure_input="$ac_file.  "
13788   fi
13789   configure_input=$configure_input"Generated from `echo $ac_file_in |
13790                                      sed 's,.*/,,'` by configure."
13791
13792   # First look for the input files in the build tree, otherwise in the
13793   # src tree.
13794   ac_file_inputs=`IFS=:
13795     for f in $ac_file_in; do
13796       case $f in
13797       -) echo $tmp/stdin ;;
13798       [\\/$]*)
13799          # Absolute (can't be DOS-style, as IFS=:)
13800          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13801 echo "$as_me: error: cannot find input file: $f" >&2;}
13802    { (exit 1); exit 1; }; }
13803          echo "$f";;
13804       *) # Relative
13805          if test -f "$f"; then
13806            # Build tree
13807            echo "$f"
13808          elif test -f "$srcdir/$f"; then
13809            # Source tree
13810            echo "$srcdir/$f"
13811          else
13812            # /dev/null tree
13813            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13814 echo "$as_me: error: cannot find input file: $f" >&2;}
13815    { (exit 1); exit 1; }; }
13816          fi;;
13817       esac
13818     done` || { (exit 1); exit 1; }
13819 _ACEOF
13820 cat >>$CONFIG_STATUS <<_ACEOF
13821   sed "$ac_vpsub
13822 $extrasub
13823 _ACEOF
13824 cat >>$CONFIG_STATUS <<\_ACEOF
13825 :t
13826 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13827 s,@configure_input@,$configure_input,;t t
13828 s,@srcdir@,$ac_srcdir,;t t
13829 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13830 s,@top_srcdir@,$ac_top_srcdir,;t t
13831 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13832 s,@builddir@,$ac_builddir,;t t
13833 s,@abs_builddir@,$ac_abs_builddir,;t t
13834 s,@top_builddir@,$ac_top_builddir,;t t
13835 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13836 s,@INSTALL@,$ac_INSTALL,;t t
13837 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13838   rm -f $tmp/stdin
13839   if test x"$ac_file" != x-; then
13840     mv $tmp/out $ac_file
13841   else
13842     cat $tmp/out
13843     rm -f $tmp/out
13844   fi
13845
13846 done
13847 _ACEOF
13848
13849 cat >>$CONFIG_STATUS <<\_ACEOF
13850
13851 { (exit 0); exit 0; }
13852 _ACEOF
13853 chmod +x $CONFIG_STATUS
13854 ac_clean_files=$ac_clean_files_save
13855
13856
13857 # configure is writing to config.log, and then calls config.status.
13858 # config.status does its own redirection, appending to config.log.
13859 # Unfortunately, on DOS this fails, as config.log is still kept open
13860 # by configure, so config.status won't be able to write to it; its
13861 # output is simply discarded.  So we exec the FD to /dev/null,
13862 # effectively closing config.log, so it can be properly (re)opened and
13863 # appended to by config.status.  When coming back to configure, we
13864 # need to make the FD available again.
13865 if test "$no_create" != yes; then
13866   ac_cs_success=:
13867   ac_config_status_args=
13868   test "$silent" = yes &&
13869     ac_config_status_args="$ac_config_status_args --quiet"
13870   exec 5>/dev/null
13871   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13872   exec 5>>config.log
13873   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13874   # would make configure fail if this is the last instruction.
13875   $ac_cs_success || { (exit 1); exit 1; }
13876 fi
13877