configure

   1 #! /bin/sh
   2
   3 # Guess values for system-dependent variables and create Makefiles.
   4 # Generated automatically using autoconf version 2.13
   5 # Copyright (C) 1992, 93, 94, 95, 96 Free Software Foundation, Inc.
   6 #
   7 # This configure script is free software; the Free Software Foundation
   8 # gives unlimited permission to copy, distribute and modify it.
   9
  10 # Defaults:
  11 ac_help=
  12 ac_default_prefix=/usr/local
  13 # Any additions from configure.in:
  14 ac_help="$ac_help
  15   --enable-libada        Builds libada directory"
  16 ac_help="$ac_help
  17   --enable-libssp        Builds libssp directory"
  18 ac_help="$ac_help
  19   --with-mpfr-dir=PATH    Specify source directory for MPFR library"
  20 ac_help="$ac_help
  21   --with-mpfr=PATH        Specify directory for installed MPFR library"
  22 ac_help="$ac_help
  23   --with-gmp-dir=PATH     Specify source directory for GMP library"
  24 ac_help="$ac_help
  25   --with-gmp=PATH         Specify directory for installed GMP library"
  26 ac_help="$ac_help
  27   --with-build-sysroot=sysroot
  28                           use sysroot as the system root during the build"
  29 ac_help="$ac_help
  30   --enable-bootstrap           Enable bootstrapping [yes if native build]"
  31 ac_help="$ac_help
  32   --enable-serial-[{host,target,build}-]configure
  33                           Force sequential configuration of
  34                           sub-packages for the host, target or build
  35                           machine, or all sub-packages"
  36 ac_help="$ac_help
  37   --with-build-time-tools=path
  38                           use given path to find target tools during the build"
  39 ac_help="$ac_help
  40   --enable-maintainer-mode enable make rules and dependencies not useful
  41                           (and sometimes confusing) to the casual installer"
  42 ac_help="$ac_help
  43   --enable-werror         enable -Werror in bootstrap stage2 and later"
  44
  45 # Initialize some variables set by options.
  46 # The variables have the same names as the options, with
  47 # dashes changed to underlines.
  48 build=NONE
  49 cache_file=./config.cache
  50 exec_prefix=NONE
  51 host=NONE
  52 no_create=
  53 nonopt=NONE
  54 no_recursion=
  55 prefix=NONE
  56 program_prefix=NONE
  57 program_suffix=NONE
  58 program_transform_name=s,x,x,
  59 silent=
  60 site=
  61 srcdir=
  62 target=NONE
  63 verbose=
  64 x_includes=NONE
  65 x_libraries=NONE
  66 bindir='${exec_prefix}/bin'
  67 sbindir='${exec_prefix}/sbin'
  68 libexecdir='${exec_prefix}/libexec'
  69 datadir='${prefix}/share'
  70 sysconfdir='${prefix}/etc'
  71 sharedstatedir='${prefix}/com'
  72 localstatedir='${prefix}/var'
  73 libdir='${exec_prefix}/lib'
  74 includedir='${prefix}/include'
  75 oldincludedir='/usr/include'
  76 infodir='${prefix}/info'
  77 mandir='${prefix}/man'
  78
  79 # Initialize some other variables.
  80 subdirs=
  81 MFLAGS= MAKEFLAGS=
  82 SHELL=${CONFIG_SHELL-/bin/sh}
  83 # Maximum number of lines to put in a shell here document.
  84 ac_max_here_lines=12
  85
  86 ac_prev=
  87 for ac_option
  88 do
  89
  90   # If the previous option needs an argument, assign it.
  91   if test -n "$ac_prev"; then
  92     eval "$ac_prev=\$ac_option"
  93     ac_prev=
  94     continue
  95   fi
  96
  97   case "$ac_option" in
  98   -*=*) ac_optarg=`echo "$ac_option" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
  99   *) ac_optarg= ;;
 100   esac
 101
 102   # Accept the important Cygnus configure options, so we can diagnose typos.
 103
 104   case "$ac_option" in
 105
 106   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 107     ac_prev=bindir ;;
 108   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 109     bindir="$ac_optarg" ;;
 110
 111   -build | --build | --buil | --bui | --bu)
 112     ac_prev=build ;;
 113   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 114     build="$ac_optarg" ;;
 115
 116   -cache-file | --cache-file | --cache-fil | --cache-fi \
 117   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 118     ac_prev=cache_file ;;
 119   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 120   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 121     cache_file="$ac_optarg" ;;
 122
 123   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 124     ac_prev=datadir ;;
 125   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 126   | --da=*)
 127     datadir="$ac_optarg" ;;
 128
 129   -disable-* | --disable-*)
 130     ac_feature=`echo $ac_option|sed -e 's/-*disable-//'`
 131     # Reject names that are not valid shell variable names.
 132     if test -n "`echo $ac_feature| sed 's/[-a-zA-Z0-9_]//g'`"; then
 133       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 134     fi
 135     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 136     eval "enable_${ac_feature}=no" ;;
 137
 138   -enable-* | --enable-*)
 139     ac_feature=`echo $ac_option|sed -e 's/-*enable-//' -e 's/=.*//'`
 140     # Reject names that are not valid shell variable names.
 141     if test -n "`echo $ac_feature| sed 's/[-_a-zA-Z0-9]//g'`"; then
 142       { echo "configure: error: $ac_feature: invalid feature name" 1>&2; exit 1; }
 143     fi
 144     ac_feature=`echo $ac_feature| sed 's/-/_/g'`
 145     case "$ac_option" in
 146       *=*) ;;
 147       *) ac_optarg=yes ;;
 148     esac
 149     eval "enable_${ac_feature}='$ac_optarg'" ;;
 150
 151   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 152   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 153   | --exec | --exe | --ex)
 154     ac_prev=exec_prefix ;;
 155   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 156   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 157   | --exec=* | --exe=* | --ex=*)
 158     exec_prefix="$ac_optarg" ;;
 159
 160   -gas | --gas | --ga | --g)
 161     # Obsolete; use --with-gas.
 162     with_gas=yes ;;
 163
 164   -help | --help | --hel | --he)
 165     # Omit some internal or obsolete options to make the list less imposing.
 166     # This message is too long to be a string in the A/UX 3.1 sh.
 167     cat << EOF
 168 Usage: configure [options] [host]
 169 Options: [defaults in brackets after descriptions]
 170 Configuration:
 171   --cache-file=FILE       cache test results in FILE
 172   --help                  print this message
 173   --no-create             do not create output files
 174   --quiet, --silent       do not print \`checking...' messages
 175   --version               print the version of autoconf that created configure
 176 Directory and file names:
 177   --prefix=PREFIX         install architecture-independent files in PREFIX
 178                           [$ac_default_prefix]
 179   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 180                           [same as prefix]
 181   --bindir=DIR            user executables in DIR [EPREFIX/bin]
 182   --sbindir=DIR           system admin executables in DIR [EPREFIX/sbin]
 183   --libexecdir=DIR        program executables in DIR [EPREFIX/libexec]
 184   --datadir=DIR           read-only architecture-independent data in DIR
 185                           [PREFIX/share]
 186   --sysconfdir=DIR        read-only single-machine data in DIR [PREFIX/etc]
 187   --sharedstatedir=DIR    modifiable architecture-independent data in DIR
 188                           [PREFIX/com]
 189   --localstatedir=DIR     modifiable single-machine data in DIR [PREFIX/var]
 190   --libdir=DIR            object code libraries in DIR [EPREFIX/lib]
 191   --includedir=DIR        C header files in DIR [PREFIX/include]
 192   --oldincludedir=DIR     C header files for non-gcc in DIR [/usr/include]
 193   --infodir=DIR           info documentation in DIR [PREFIX/info]
 194   --mandir=DIR            man documentation in DIR [PREFIX/man]
 195   --srcdir=DIR            find the sources in DIR [configure dir or ..]
 196   --program-prefix=PREFIX prepend PREFIX to installed program names
 197   --program-suffix=SUFFIX append SUFFIX to installed program names
 198   --program-transform-name=PROGRAM
 199                           run sed PROGRAM on installed program names
 200 EOF
 201     cat << EOF
 202 Host type:
 203   --build=BUILD           configure for building on BUILD [BUILD=HOST]
 204   --host=HOST             configure for HOST [guessed]
 205   --target=TARGET         configure for TARGET [TARGET=HOST]
 206 Features and packages:
 207   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 208   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 209   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 210   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 211   --x-includes=DIR        X include files are in DIR
 212   --x-libraries=DIR       X library files are in DIR
 213 EOF
 214     if test -n "$ac_help"; then
 215       echo "--enable and --with options recognized:$ac_help"
 216     fi
 217     exit 0 ;;
 218
 219   -host | --host | --hos | --ho)
 220     ac_prev=host ;;
 221   -host=* | --host=* | --hos=* | --ho=*)
 222     host="$ac_optarg" ;;
 223
 224   -includedir | --includedir | --includedi | --included | --include \
 225   | --includ | --inclu | --incl | --inc)
 226     ac_prev=includedir ;;
 227   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 228   | --includ=* | --inclu=* | --incl=* | --inc=*)
 229     includedir="$ac_optarg" ;;
 230
 231   -infodir | --infodir | --infodi | --infod | --info | --inf)
 232     ac_prev=infodir ;;
 233   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 234     infodir="$ac_optarg" ;;
 235
 236   -libdir | --libdir | --libdi | --libd)
 237     ac_prev=libdir ;;
 238   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 239     libdir="$ac_optarg" ;;
 240
 241   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 242   | --libexe | --libex | --libe)
 243     ac_prev=libexecdir ;;
 244   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 245   | --libexe=* | --libex=* | --libe=*)
 246     libexecdir="$ac_optarg" ;;
 247
 248   -localstatedir | --localstatedir | --localstatedi | --localstated \
 249   | --localstate | --localstat | --localsta | --localst \
 250   | --locals | --local | --loca | --loc | --lo)
 251     ac_prev=localstatedir ;;
 252   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 253   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 254   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 255     localstatedir="$ac_optarg" ;;
 256
 257   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 258     ac_prev=mandir ;;
 259   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 260     mandir="$ac_optarg" ;;
 261
 262   -nfp | --nfp | --nf)
 263     # Obsolete; use --without-fp.
 264     with_fp=no ;;
 265
 266   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 267   | --no-cr | --no-c)
 268     no_create=yes ;;
 269
 270   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 271   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 272     no_recursion=yes ;;
 273
 274   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 275   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 276   | --oldin | --oldi | --old | --ol | --o)
 277     ac_prev=oldincludedir ;;
 278   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 279   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 280   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 281     oldincludedir="$ac_optarg" ;;
 282
 283   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 284     ac_prev=prefix ;;
 285   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 286     prefix="$ac_optarg" ;;
 287
 288   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 289   | --program-pre | --program-pr | --program-p)
 290     ac_prev=program_prefix ;;
 291   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 292   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 293     program_prefix="$ac_optarg" ;;
 294
 295   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 296   | --program-suf | --program-su | --program-s)
 297     ac_prev=program_suffix ;;
 298   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 299   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 300     program_suffix="$ac_optarg" ;;
 301
 302   -program-transform-name | --program-transform-name \
 303   | --program-transform-nam | --program-transform-na \
 304   | --program-transform-n | --program-transform- \
 305   | --program-transform | --program-transfor \
 306   | --program-transfo | --program-transf \
 307   | --program-trans | --program-tran \
 308   | --progr-tra | --program-tr | --program-t)
 309     ac_prev=program_transform_name ;;
 310   -program-transform-name=* | --program-transform-name=* \
 311   | --program-transform-nam=* | --program-transform-na=* \
 312   | --program-transform-n=* | --program-transform-=* \
 313   | --program-transform=* | --program-transfor=* \
 314   | --program-transfo=* | --program-transf=* \
 315   | --program-trans=* | --program-tran=* \
 316   | --progr-tra=* | --program-tr=* | --program-t=*)
 317     program_transform_name="$ac_optarg" ;;
 318
 319   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 320   | -silent | --silent | --silen | --sile | --sil)
 321     silent=yes ;;
 322
 323   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 324     ac_prev=sbindir ;;
 325   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 326   | --sbi=* | --sb=*)
 327     sbindir="$ac_optarg" ;;
 328
 329   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 330   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 331   | --sharedst | --shareds | --shared | --share | --shar \
 332   | --sha | --sh)
 333     ac_prev=sharedstatedir ;;
 334   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 335   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 336   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 337   | --sha=* | --sh=*)
 338     sharedstatedir="$ac_optarg" ;;
 339
 340   -site | --site | --sit)
 341     ac_prev=site ;;
 342   -site=* | --site=* | --sit=*)
 343     site="$ac_optarg" ;;
 344
 345   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 346     ac_prev=srcdir ;;
 347   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 348     srcdir="$ac_optarg" ;;
 349
 350   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 351   | --syscon | --sysco | --sysc | --sys | --sy)
 352     ac_prev=sysconfdir ;;
 353   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 354   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 355     sysconfdir="$ac_optarg" ;;
 356
 357   -target | --target | --targe | --targ | --tar | --ta | --t)
 358     ac_prev=target ;;
 359   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 360     target="$ac_optarg" ;;
 361
 362   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 363     verbose=yes ;;
 364
 365   -version | --version | --versio | --versi | --vers)
 366     echo "configure generated by autoconf version 2.13"
 367     exit 0 ;;
 368
 369   -with-* | --with-*)
 370     ac_package=`echo $ac_option|sed -e 's/-*with-//' -e 's/=.*//'`
 371     # Reject names that are not valid shell variable names.
 372     if test -n "`echo $ac_package| sed 's/[-_a-zA-Z0-9]//g'`"; then
 373       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 374     fi
 375     ac_package=`echo $ac_package| sed 's/-/_/g'`
 376     case "$ac_option" in
 377       *=*) ;;
 378       *) ac_optarg=yes ;;
 379     esac
 380     eval "with_${ac_package}='$ac_optarg'" ;;
 381
 382   -without-* | --without-*)
 383     ac_package=`echo $ac_option|sed -e 's/-*without-//'`
 384     # Reject names that are not valid shell variable names.
 385     if test -n "`echo $ac_package| sed 's/[-a-zA-Z0-9_]//g'`"; then
 386       { echo "configure: error: $ac_package: invalid package name" 1>&2; exit 1; }
 387     fi
 388     ac_package=`echo $ac_package| sed 's/-/_/g'`
 389     eval "with_${ac_package}=no" ;;
 390
 391   --x)
 392     # Obsolete; use --with-x.
 393     with_x=yes ;;
 394
 395   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 396   | --x-incl | --x-inc | --x-in | --x-i)
 397     ac_prev=x_includes ;;
 398   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 399   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 400     x_includes="$ac_optarg" ;;
 401
 402   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 403   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 404     ac_prev=x_libraries ;;
 405   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 406   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 407     x_libraries="$ac_optarg" ;;
 408
 409   -*) { echo "configure: error: $ac_option: invalid option; use --help to show usage" 1>&2; exit 1; }
 410     ;;
 411
 412   *)
 413     if test -n "`echo $ac_option| sed 's/[-a-z0-9.]//g'`"; then
 414       echo "configure: warning: $ac_option: invalid host type" 1>&2
 415     fi
 416     if test "x$nonopt" != xNONE; then
 417       { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; }
 418     fi
 419     nonopt="$ac_option"
 420     ;;
 421
 422   esac
 423 done
 424
 425 if test -n "$ac_prev"; then
 426   { echo "configure: error: missing argument to --`echo $ac_prev | sed 's/_/-/g'`" 1>&2; exit 1; }
 427 fi
 428
 429 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
 430
 431 # File descriptor usage:
 432 # 0 standard input
 433 # 1 file creation
 434 # 2 errors and warnings
 435 # 3 some systems may open it to /dev/tty
 436 # 4 used on the Kubota Titan
 437 # 6 checking for... messages and results
 438 # 5 compiler messages saved in config.log
 439 if test "$silent" = yes; then
 440   exec 6>/dev/null
 441 else
 442   exec 6>&1
 443 fi
 444 exec 5>./config.log
 445
 446 echo "\
 447 This file contains any messages produced by compilers while
 448 running configure, to aid debugging if configure makes a mistake.
 449 " 1>&5
 450
 451 # Strip out --no-create and --no-recursion so they do not pile up.
 452 # Also quote any args containing shell metacharacters.
 453 ac_configure_args=
 454 for ac_arg
 455 do
 456   case "$ac_arg" in
 457   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 458   | --no-cr | --no-c) ;;
 459   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 460   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) ;;
 461   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?]*)
 462   ac_configure_args="$ac_configure_args '$ac_arg'" ;;
 463   *) ac_configure_args="$ac_configure_args $ac_arg" ;;
 464   esac
 465 done
 466
 467 # NLS nuisances.
 468 # Only set these to C if already set.  These must not be set unconditionally
 469 # because not all systems understand e.g. LANG=C (notably SCO).
 470 # Fixing LC_MESSAGES prevents Solaris sh from translating var values in `set'!
 471 # Non-C LC_CTYPE values break the ctype check.
 472 if test "${LANG+set}"   = set; then LANG=C;   export LANG;   fi
 473 if test "${LC_ALL+set}" = set; then LC_ALL=C; export LC_ALL; fi
 474 if test "${LC_MESSAGES+set}" = set; then LC_MESSAGES=C; export LC_MESSAGES; fi
 475 if test "${LC_CTYPE+set}"    = set; then LC_CTYPE=C;    export LC_CTYPE;    fi
 476
 477 # confdefs.h avoids OS command line length limits that DEFS can exceed.
 478 rm -rf conftest* confdefs.h
 479 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
 480 echo > confdefs.h
 481
 482 # A filename unique to this package, relative to the directory that
 483 # configure is in, which we can look for to find out if srcdir is correct.
 484 ac_unique_file=move-if-change
 485
 486 # Find the source files, if location was not specified.
 487 if test -z "$srcdir"; then
 488   ac_srcdir_defaulted=yes
 489   # Try the directory containing this script, then its parent.
 490   ac_prog=$0
 491   ac_confdir=`echo $ac_prog|sed 's%/[^/][^/]*$%%'`
 492   test "x$ac_confdir" = "x$ac_prog" && ac_confdir=.
 493   srcdir=$ac_confdir
 494   if test ! -r $srcdir/$ac_unique_file; then
 495     srcdir=..
 496   fi
 497 else
 498   ac_srcdir_defaulted=no
 499 fi
 500 if test ! -r $srcdir/$ac_unique_file; then
 501   if test "$ac_srcdir_defaulted" = yes; then
 502     { echo "configure: error: can not find sources in $ac_confdir or .." 1>&2; exit 1; }
 503   else
 504     { echo "configure: error: can not find sources in $srcdir" 1>&2; exit 1; }
 505   fi
 506 fi
 507 srcdir=`echo "${srcdir}" | sed 's%\([^/]\)/*$%\1%'`
 508
 509 # Prefer explicitly selected file to automatically selected ones.
 510 if test -z "$CONFIG_SITE"; then
 511   if test "x$prefix" != xNONE; then
 512     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
 513   else
 514     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
 515   fi
 516 fi
 517 for ac_site_file in $CONFIG_SITE; do
 518   if test -r "$ac_site_file"; then
 519     echo "loading site script $ac_site_file"
 520     . "$ac_site_file"
 521   fi
 522 done
 523
 524 if test -r "$cache_file"; then
 525   echo "loading cache $cache_file"
 526   . $cache_file
 527 else
 528   echo "creating cache $cache_file"
 529   > $cache_file
 530 fi
 531
 532 ac_ext=c
 533 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
 534 ac_cpp='$CPP $CPPFLAGS'
 535 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
 536 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
 537 cross_compiling=$ac_cv_prog_cc_cross
 538
 539 ac_exeext=
 540 ac_objext=o
 541 if (echo "testing\c"; echo 1,2,3) | grep c >/dev/null; then
 542   # Stardent Vistra SVR4 grep lacks -e, says [email protected].
 543   if (echo -n testing; echo 1,2,3) | sed s/-n/xn/ | grep xn >/dev/null; then
 544     ac_n= ac_c='
 545 ' ac_t='        '
 546   else
 547     ac_n=-n ac_c= ac_t=
 548   fi
 549 else
 550   ac_n= ac_c='\c' ac_t=
 551 fi
 552
 553
 554
 555 ac_aux_dir=
 556 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
 557   if test -f $ac_dir/install-sh; then
 558     ac_aux_dir=$ac_dir
 559     ac_install_sh="$ac_aux_dir/install-sh -c"
 560     break
 561   elif test -f $ac_dir/install.sh; then
 562     ac_aux_dir=$ac_dir
 563     ac_install_sh="$ac_aux_dir/install.sh -c"
 564     break
 565   fi
 566 done
 567 if test -z "$ac_aux_dir"; then
 568   { echo "configure: error: can not find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." 1>&2; exit 1; }
 569 fi
 570 ac_config_guess=$ac_aux_dir/config.guess
 571 ac_config_sub=$ac_aux_dir/config.sub
 572 ac_configure=$ac_aux_dir/configure # This should be Cygnus configure.
 573
 574
 575 # Do some error checking and defaulting for the host and target type.
 576 # The inputs are:
 577 #    configure --host=HOST --target=TARGET --build=BUILD NONOPT
 578 #
 579 # The rules are:
 580 # 1. You are not allowed to specify --host, --target, and nonopt at the
 581 #    same time.
 582 # 2. Host defaults to nonopt.
 583 # 3. If nonopt is not specified, then host defaults to the current host,
 584 #    as determined by config.guess.
 585 # 4. Target and build default to nonopt.
 586 # 5. If nonopt is not specified, then target and build default to host.
 587
 588 # The aliases save the names the user supplied, while $host etc.
 589 # will get canonicalized.
 590 case $host---$target---$nonopt in
 591 NONE---*---* | *---NONE---* | *---*---NONE) ;;
 592 *) { echo "configure: error: can only configure for one host and one target at a time" 1>&2; exit 1; } ;;
 593 esac
 594
 595
 596 # Make sure we can run config.sub.
 597 if ${CONFIG_SHELL-/bin/sh} $ac_config_sub sun4 >/dev/null 2>&1; then :
 598 else { echo "configure: error: can not run $ac_config_sub" 1>&2; exit 1; }
 599 fi
 600
 601 echo $ac_n "checking host system type""... $ac_c" 1>&6
 602 echo "configure:603: checking host system type" >&5
 603
 604 host_alias=$host
 605 case "$host_alias" in
 606 NONE)
 607   case $nonopt in
 608   NONE)
 609     if host_alias=`${CONFIG_SHELL-/bin/sh} $ac_config_guess`; then :
 610     else { echo "configure: error: can not guess host type; you must specify one" 1>&2; exit 1; }
 611     fi ;;
 612   *) host_alias=$nonopt ;;
 613   esac ;;
 614 esac
 615
 616 host=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $host_alias`
 617 host_cpu=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 618 host_vendor=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 619 host_os=`echo $host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 620 echo "$ac_t""$host" 1>&6
 621
 622 echo $ac_n "checking target system type""... $ac_c" 1>&6
 623 echo "configure:624: checking target system type" >&5
 624
 625 target_alias=$target
 626 case "$target_alias" in
 627 NONE)
 628   case $nonopt in
 629   NONE) target_alias=$host_alias ;;
 630   *) target_alias=$nonopt ;;
 631   esac ;;
 632 esac
 633
 634 target=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $target_alias`
 635 target_cpu=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 636 target_vendor=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 637 target_os=`echo $target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 638 echo "$ac_t""$target" 1>&6
 639
 640 echo $ac_n "checking build system type""... $ac_c" 1>&6
 641 echo "configure:642: checking build system type" >&5
 642
 643 build_alias=$build
 644 case "$build_alias" in
 645 NONE)
 646   case $nonopt in
 647   NONE) build_alias=$host_alias ;;
 648   *) build_alias=$nonopt ;;
 649   esac ;;
 650 esac
 651
 652 build=`${CONFIG_SHELL-/bin/sh} $ac_config_sub $build_alias`
 653 build_cpu=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
 654 build_vendor=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
 655 build_os=`echo $build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
 656 echo "$ac_t""$build" 1>&6
 657
 658 test "$host_alias" != "$target_alias" &&
 659   test "$program_prefix$program_suffix$program_transform_name" = \
 660     NONENONEs,x,x, &&
 661   program_prefix=${target_alias}-
 662
 663 if test "$program_transform_name" = s,x,x,; then
 664   program_transform_name=
 665 else
 666   # Double any \ or $.  echo might interpret backslashes.
 667   cat <<\EOF_SED > conftestsed
 668 s,\\,\\\\,g; s,\$,$$,g
 669 EOF_SED
 670   program_transform_name="`echo $program_transform_name|sed -f conftestsed`"
 671   rm -f conftestsed
 672 fi
 673 test "$program_prefix" != NONE &&
 674   program_transform_name="s,^,${program_prefix},; $program_transform_name"
 675 # Use a double $ so make ignores it.
 676 test "$program_suffix" != NONE &&
 677   program_transform_name="s,\$\$,${program_suffix},; $program_transform_name"
 678
 679 # sed with no file args requires a program.
 680 test "$program_transform_name" = "" && program_transform_name="s,x,x,"
 681
 682
 683 # Get 'install' or 'install-sh' and its variants.
 684 # Find a good install program.  We prefer a C program (faster),
 685 # so one script is as good as another.  But avoid the broken or
 686 # incompatible versions:
 687 # SysV /etc/install, /usr/sbin/install
 688 # SunOS /usr/etc/install
 689 # IRIX /sbin/install
 690 # AIX /bin/install
 691 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
 692 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
 693 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
 694 # ./install, which can be erroneously created by make from ./install.sh.
 695 echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6
 696 echo "configure:697: checking for a BSD compatible install" >&5
 697 if test -z "$INSTALL"; then
 698 if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then
 699   echo $ac_n "(cached) $ac_c" 1>&6
 700 else
 701     IFS="${IFS=         }"; ac_save_IFS="$IFS"; IFS=":"
 702   for ac_dir in $PATH; do
 703     # Account for people who put trailing slashes in PATH elements.
 704     case "$ac_dir/" in
 705     /|./|.//|/etc/*|/usr/sbin/*|/usr/etc/*|/sbin/*|/usr/afsws/bin/*|/usr/ucb/*) ;;
 706     *)
 707       # OSF1 and SCO ODT 3.0 have their own names for install.
 708       # Don't use installbsd from OSF since it installs stuff as root
 709       # by default.
 710       for ac_prog in ginstall scoinst install; do
 711         if test -f $ac_dir/$ac_prog; then
 712           if test $ac_prog = install &&
 713             grep dspmsg $ac_dir/$ac_prog >/dev/null 2>&1; then
 714             # AIX install.  It has an incompatible calling convention.
 715             :
 716           else
 717             ac_cv_path_install="$ac_dir/$ac_prog -c"
 718             break 2
 719           fi
 720         fi
 721       done
 722       ;;
 723     esac
 724   done
 725   IFS="$ac_save_IFS"
 726
 727 fi
 728   if test "${ac_cv_path_install+set}" = set; then
 729     INSTALL="$ac_cv_path_install"
 730   else
 731     # As a last resort, use the slow shell script.  We don't cache a
 732     # path for INSTALL within a source directory, because that will
 733     # break other packages using the cache if that directory is
 734     # removed, or if the path is relative.
 735     INSTALL="$ac_install_sh"
 736   fi
 737 fi
 738 echo "$ac_t""$INSTALL" 1>&6
 739
 740 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
 741 # It thinks the first close brace ends the variable substitution.
 742 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
 743
 744 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}'
 745
 746 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
 747
 748 echo $ac_n "checking whether ln works""... $ac_c" 1>&6
 749 echo "configure:750: checking whether ln works" >&5
 750 if eval "test \"`echo '$''{'acx_cv_prog_LN'+set}'`\" = set"; then
 751   echo $ac_n "(cached) $ac_c" 1>&6
 752 else
 753   rm -f conftestdata_t
 754 echo >conftestdata_f
 755 if ln conftestdata_f conftestdata_t 2>/dev/null
 756 then
 757   acx_cv_prog_LN=ln
 758 else
 759   acx_cv_prog_LN=no
 760 fi
 761 rm -f conftestdata_f conftestdata_t
 762
 763 fi
 764 if test $acx_cv_prog_LN = no; then
 765   LN="cp"
 766   echo "$ac_t""no, using $LN" 1>&6
 767 else
 768   LN="$acx_cv_prog_LN"
 769   echo "$ac_t""yes" 1>&6
 770 fi
 771
 772 echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6
 773 echo "configure:774: checking whether ln -s works" >&5
 774 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then
 775   echo $ac_n "(cached) $ac_c" 1>&6
 776 else
 777   rm -f conftestdata
 778 if ln -s X conftestdata 2>/dev/null
 779 then
 780   rm -f conftestdata
 781   ac_cv_prog_LN_S="ln -s"
 782 else
 783   ac_cv_prog_LN_S=ln
 784 fi
 785 fi
 786 LN_S="$ac_cv_prog_LN_S"
 787 if test "$ac_cv_prog_LN_S" = "ln -s"; then
 788   echo "$ac_t""yes" 1>&6
 789 else
 790   echo "$ac_t""no" 1>&6
 791 fi
 792
 793
 794 ### we might need to use some other shell than /bin/sh for running subshells
 795 ### If we are on Windows, search for the shell.  This will permit people
 796 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
 797 ### without also having to set CONFIG_SHELL.  This code will work when
 798 ### using bash, which sets OSTYPE.
 799 case "${OSTYPE}" in
 800 *win32*)
 801   if test x${CONFIG_SHELL} = x ; then
 802     if test ! -f /bin/sh ; then
 803       if test x${SHELL} != x && test -f ${SHELL} ; then
 804         CONFIG_SHELL=${SHELL}
 805         export CONFIG_SHELL
 806       else
 807         for prog in sh sh.exe bash bash.exe; do
 808           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
 809           for dir in $PATH; do
 810             test -z "$dir" && dir=.
 811             if test -f $dir/$prog; then
 812               CONFIG_SHELL=$dir/$prog
 813               export CONFIG_SHELL
 814               break
 815             fi
 816           done
 817           IFS="$save_ifs"
 818           test -n "${CONFIG_SHELL}" && break
 819         done
 820       fi
 821     fi
 822   fi
 823   ;;
 824 esac
 825
 826 config_shell=${CONFIG_SHELL-/bin/sh}
 827
 828 progname=$0
 829 # if PWD already has a value, it is probably wrong.
 830 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
 831
 832 # Export original configure arguments for use by sub-configures.  These
 833 # will be expanded by make, so quote '$'.
 834 tmp="$progname $@"
 835 sed -e 's,\$,$$,g' <<EOF_SED > conftestsed.out
 836 $tmp
 837 EOF_SED
 838 TOPLEVEL_CONFIGURE_ARGUMENTS=`cat conftestsed.out`
 839 rm -f conftestsed.out
 840
 841
 842 moveifchange=${srcdir}/move-if-change
 843
 844 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
 845
 846 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
 847 # a relative path.
 848 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
 849   INSTALL="${srcpwd}/install-sh -c"
 850 fi
 851
 852 # Set srcdir to "." if that's what it is.
 853 # This is important for multilib support.
 854 pwd=`${PWDCMD-pwd}`
 855 if test "${pwd}" = "${srcpwd}" ; then
 856   srcdir=.
 857 fi
 858
 859 topsrcdir=$srcpwd
 860
 861 extra_host_args=
 862
 863 ### To add a new directory to the tree, first choose whether it is a target
 864 ### or a host dependent tool.  Then put it into the appropriate list
 865 ### (library or tools, host or target), doing a dependency sort.
 866
 867 # Subdirs will be configured in the order listed in build_configdirs,
 868 # configdirs, or target_configdirs; see the serialization section below.
 869
 870 # Dependency sorting is only needed when *configuration* must be done in
 871 # a particular order.  In all cases a dependency should be specified in
 872 # the Makefile, whether or not it's implicitly specified here.
 873
 874 # Double entries in build_configdirs, configdirs, or target_configdirs may
 875 # cause circular dependencies and break everything horribly.
 876
 877 # these library is used by various programs built for the build
 878 # environment
 879 #
 880 build_libs="build-libiberty"
 881
 882 # these tools are built for the build environment
 883 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
 884
 885 # these libraries are used by various programs built for the host environment
 886 #
 887 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber"
 888
 889 # these tools are built for the host environment
 890 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
 891 # know that we are building the simulator.
 892 # binutils, gas and ld appear in that order because it makes sense to run
 893 # "make check" in that particular order.
 894 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"
 895
 896 # libgcj represents the runtime libraries only used by gcj.
 897 libgcj="target-libffi \
 898         target-boehm-gc \
 899         target-zlib \
 900         target-qthreads \
 901         target-libjava"
 902
 903 # these libraries are built for the target environment, and are built after
 904 # the host libraries and the host tools (which may be a cross compiler)
 905 #
 906 target_libraries="target-libiberty \
 907                 target-libgloss \
 908                 target-newlib \
 909                 target-libstdc++-v3 \
 910                 target-libmudflap \
 911                 target-libssp \
 912                 target-libgfortran \
 913                 ${libgcj} \
 914                 target-libobjc \
 915                 target-libada"
 916
 917 # these tools are built using the target libraries, and are intended to
 918 # run only in the target environment
 919 #
 920 # note: any program that *uses* libraries that are in the "target_libraries"
 921 # list belongs in this list.  those programs are also very likely
 922 # candidates for the "native_only" list which follows
 923 #
 924 target_tools="target-examples target-groff target-gperf target-rda"
 925
 926 ################################################################################
 927
 928 ## All tools belong in one of the four categories, and are assigned above
 929 ## We assign ${configdirs} this way to remove all embedded newlines.  This
 930 ## is important because configure will choke if they ever get through.
 931 ## ${configdirs} is directories we build using the host tools.
 932 ## ${target_configdirs} is directories we build using the target tools.
 933 configdirs=`echo ${host_libs} ${host_tools}`
 934 target_configdirs=`echo ${target_libraries} ${target_tools}`
 935 build_configdirs=`echo ${build_libs} ${build_tools}`
 936
 937 ################################################################################
 938
 939 srcname="gnu development package"
 940
 941 # This gets set non-empty for some net releases of packages.
 942 appdirs=""
 943
 944 # Define is_cross_compiler to save on calls to 'test'.
 945 is_cross_compiler=
 946 if test x"${host}" = x"${target}" ; then
 947   is_cross_compiler=no
 948 else
 949   is_cross_compiler=yes
 950 fi
 951
 952 # Find the build and target subdir names.
 953  case ${build_alias} in
 954   "") build_noncanonical=${build} ;;
 955   *) build_noncanonical=${build_alias} ;;
 956 esac
 957
 958  case ${host_alias} in
 959   "") host_noncanonical=${build_noncanonical} ;;
 960   *) host_noncanonical=${host_alias} ;;
 961 esac
 962
 963  case ${target_alias} in
 964   "") target_noncanonical=${host_noncanonical} ;;
 965   *) target_noncanonical=${target_alias} ;;
 966 esac
 967
 968   # Prefix 'build-' so this never conflicts with target_subdir.
 969 build_subdir="build-${build_noncanonical}"
 970 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
 971 if ( test $srcdir = . && test -d gcc ) \
 972    || test -d $srcdir/../host-${host_noncanonical}; then
 973   host_subdir="host-${host_noncanonical}"
 974 else
 975   host_subdir=.
 976 fi
 977 # No prefix.
 978 target_subdir=${target_noncanonical}
 979
 980
 981 # Skipdirs are removed silently.
 982 skipdirs=
 983 # Noconfigdirs are removed loudly.
 984 noconfigdirs=""
 985
 986 use_gnu_ld=
 987 # Make sure we don't let GNU ld be added if we didn't want it.
 988 if test x$with_gnu_ld = xno ; then
 989   use_gnu_ld=no
 990   noconfigdirs="$noconfigdirs ld"
 991 fi
 992
 993 use_gnu_as=
 994 # Make sure we don't let GNU as be added if we didn't want it.
 995 if test x$with_gnu_as = xno ; then
 996   use_gnu_as=no
 997   noconfigdirs="$noconfigdirs gas"
 998 fi
 999
1000 # some tools are so dependent upon X11 that if we're not building with X,
1001 # it's not even worth trying to configure, much less build, that tool.
1002
1003 case ${with_x} in
1004   yes | "") ;; # the default value for this tree is that X11 is available
1005   no)
1006     skipdirs="${skipdirs} tk itcl libgui"
1007     # We won't be able to build gdbtk without X.
1008     enable_gdbtk=no
1009     ;;
1010   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1011 esac
1012
1013 # Some tools are only suitable for building in a "native" situation.
1014 # Remove these if host!=target.
1015 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff gprof target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
1016
1017 # Similarly, some are only suitable for cross toolchains.
1018 # Remove these if host=target.
1019 cross_only="target-libgloss target-newlib target-opcodes"
1020
1021 case $is_cross_compiler in
1022   no) skipdirs="${skipdirs} ${cross_only}" ;;
1023   yes) skipdirs="${skipdirs} ${native_only}" ;;
1024 esac
1025
1026 # If both --with-headers and --with-libs are specified, default to
1027 # --without-newlib.
1028 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1029    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1030   if test x"${with_newlib}" = x ; then
1031     with_newlib=no
1032   fi
1033 fi
1034
1035 # Recognize --with-newlib/--without-newlib.
1036 case ${with_newlib} in
1037   no) skipdirs="${skipdirs} target-newlib" ;;
1038   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1039 esac
1040
1041 # Configure extra directories which are host specific
1042
1043 case "${host}" in
1044   *-cygwin*)
1045     configdirs="$configdirs libtermcap" ;;
1046 esac
1047
1048 # A target can indicate whether a language isn't supported for some reason.
1049 # Only spaces may be used in this macro; not newlines or tabs.
1050 unsupported_languages=
1051
1052 # Remove more programs from consideration, based on the host or
1053 # target this usually means that a port of the program doesn't
1054 # exist yet.
1055
1056 case "${host}" in
1057   hppa*64*-*-*)
1058     noconfigdirs="$noconfigdirs byacc"
1059     ;;
1060   i[3456789]86-*-vsta)
1061     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
1062     ;;
1063   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
1064     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
1065     ;;
1066   i[3456789]86-*-mingw32*)
1067     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
1068     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool"
1069     ;;
1070   i[3456789]86-*-beos*)
1071     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
1072     ;;
1073   *-*-cygwin*)
1074     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
1075     ;;
1076   *-*-netbsd*)
1077     noconfigdirs="$noconfigdirs rcs"
1078     ;;
1079   ppc*-*-pe)
1080     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
1081     ;;
1082   powerpc-*-beos*)
1083     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
1084     ;;
1085 esac
1086
1087
1088 # Check whether --enable-libada or --disable-libada was given.
1089 if test "${enable_libada+set}" = set; then
1090   enableval="$enable_libada"
1091   ENABLE_LIBADA=$enableval
1092 else
1093   ENABLE_LIBADA=yes
1094 fi
1095
1096 if test "${ENABLE_LIBADA}" != "yes" ; then
1097   noconfigdirs="$noconfigdirs target-libada"
1098   noconfigdirs="$noconfigdirs gnattools"
1099 fi
1100
1101 # Check whether --enable-libssp or --disable-libssp was given.
1102 if test "${enable_libssp+set}" = set; then
1103   enableval="$enable_libssp"
1104   ENABLE_LIBSSP=$enableval
1105 else
1106   ENABLE_LIBSSP=yes
1107 fi
1108
1109 if test "${ENABLE_LIBSSP}" != "yes" ; then
1110   noconfigdirs="$noconfigdirs target-libssp"
1111 fi
1112
1113 # Save it here so that, even in case of --enable-libgcj, if the Java
1114 # front-end isn't enabled, we still get libgcj disabled.
1115 libgcj_saved=$libgcj
1116 case $enable_libgcj in
1117 yes)
1118   # If we reset it here, it won't get added to noconfigdirs in the
1119   # target-specific build rules, so it will be forcibly enabled
1120   # (unless the Java language itself isn't enabled).
1121   libgcj=
1122   ;;
1123 no)
1124   # Make sure we get it printed in the list of not supported target libs.
1125   noconfigdirs="$noconfigdirs ${libgcj}"
1126   ;;
1127 esac
1128
1129
1130 # Allow --disable-libmudflap to exclude target-libmudflap
1131 case $enable_libmudflap in
1132 yes)
1133     ;;
1134 no)
1135     noconfigdirs="$noconfigdirs target-libmudflap"
1136     ;;
1137 "")
1138     case "${target}" in
1139     *-*-linux*-gnu | *-*-gnu* | *-*-k*bsd*-gnu)
1140         # Enable libmudflap by default in GNU and friends.
1141         ;;
1142     *-*-freebsd*)
1143         # Enable libmudflap by default in FreeBSD.
1144         ;;
1145     *)
1146         # Disable it by default everywhere else.
1147         noconfigdirs="$noconfigdirs target-libmudflap"
1148         ;;
1149     esac
1150 esac
1151
1152
1153 case "${target}" in
1154   *-*-chorusos)
1155     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1156     ;;
1157   powerpc-*-darwin*)
1158     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
1159     noconfigdirs="$noconfigdirs sim target-rda"
1160     ;;
1161   *-*-darwin*)
1162     noconfigdirs="$noconfigdirs ld gas gdb gprof"
1163     noconfigdirs="$noconfigdirs sim target-rda"
1164     noconfigdirs="$noconfigdirs ${libgcj}"
1165     ;;
1166   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
1167     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1168     ;;
1169   *-*-freebsd*)
1170     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1171     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
1172         && test -f /usr/local/include/gmp.h; then
1173       with_gmp=/usr/local
1174     fi
1175
1176     # Skip some stuff that's unsupported on some FreeBSD configurations.
1177     case "${target}" in
1178       i*86-*-*) ;;
1179       alpha*-*-*) ;;
1180       *)
1181         noconfigdirs="$noconfigdirs ${libgcj}"
1182         ;;
1183     esac
1184     ;;
1185   *-*-kaos*)
1186     # Remove unsupported stuff on all kaOS configurations.
1187     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
1188     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
1189     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
1190     noconfigdirs="$noconfigdirs target-libgloss"
1191     ;;
1192   *-*-netbsd*)
1193     # Skip some stuff on all NetBSD configurations.
1194     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
1195
1196     # Skip some stuff that's unsupported on some NetBSD configurations.
1197     case "${target}" in
1198       i*86-*-netbsdelf*) ;;
1199       arm*-*-netbsdelf*) ;;
1200       *)
1201         noconfigdirs="$noconfigdirs ${libgcj}"
1202         ;;
1203     esac
1204     ;;
1205   *-*-netware*)
1206     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
1207     ;;
1208   *-*-rtems*)
1209     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1210     ;;
1211     # The tpf target doesn't support gdb yet.
1212   *-*-tpf*)
1213     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
1214     ;;
1215   *-*-uclinux*)
1216     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
1217     ;;
1218   *-*-vxworks*)
1219     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
1220     ;;
1221   m32c-*-*)
1222     noconfigdirs="$noconfigdirs target-libstdc++-v3"
1223     ;;
1224   alpha*-dec-osf*)
1225     # ld works, but does not support shared libraries.
1226     # newlib is not 64 bit ready.  I'm not sure about fileutils.
1227     # gas doesn't generate exception information.
1228     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
1229     ;;
1230   alpha*-*-*vms*)
1231     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
1232     ;;
1233   alpha*-*-linux*)
1234     # newlib is not 64 bit ready
1235     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1236     ;;
1237   alpha*-*-*)
1238     # newlib is not 64 bit ready
1239     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1240     ;;
1241   am33_2.0-*-linux*)
1242     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
1243     ;;
1244   sh-*-linux*)
1245     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
1246     ;;
1247   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
1248     noconfigdirs="$noconfigdirs ${libgcj}"
1249     noconfigdirs="$noconfigdirs target-examples"
1250     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
1251     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
1252     noconfigdirs="$noconfigdirs expect dejagnu"
1253     # the C++ libraries don't build on top of CE's C libraries
1254     noconfigdirs="$noconfigdirs target-libstdc++-v3"
1255     noconfigdirs="$noconfigdirs target-newlib"
1256     case "${host}" in
1257       *-*-cygwin*) ;; # keep gdb and readline
1258       *) noconfigdirs="$noconfigdirs gdb readline"
1259          ;;
1260     esac
1261     ;;
1262   arc-*-*)
1263     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1264     ;;
1265   arm-semi-aof )
1266     ;;
1267   arm-*-coff | strongarm-*-coff | xscale-*-coff)
1268     noconfigdirs="$noconfigdirs ${libgcj}"
1269     ;;
1270   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
1271     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
1272     ;;
1273   arm*-*-linux-gnueabi)
1274     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
1275     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
1276     ;;
1277   arm*-*-symbianelf*)
1278     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
1279     ;;
1280   arm-*-pe*)
1281     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1282     ;;
1283   thumb-*-coff)
1284     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1285     ;;
1286   thumb-*-elf)
1287     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1288     ;;
1289   thumb-*-pe)
1290     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1291     ;;
1292   arm-*-riscix*)
1293     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
1294     ;;
1295   avr-*-*)
1296     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
1297     ;;
1298   bfin-*-*)
1299     noconfigdirs="$noconfigdirs target-libgloss gdb"
1300     if test x${is_cross_compiler} != xno ; then
1301       target_configdirs="${target_configdirs} target-bsp target-cygmon"
1302     fi
1303     ;;
1304   c4x-*-* | tic4x-*-*)
1305     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1306     ;;
1307   c54x*-*-* | tic54x-*-*)
1308     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
1309     ;;
1310   cris-*-* | crisv32-*-*)
1311     unsupported_languages="$unsupported_languages java"
1312     case "${target}" in
1313       *-*-aout)
1314         unsupported_languages="$unsupported_languages fortran"
1315         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
1316       *-*-elf)
1317         unsupported_languages="$unsupported_languages fortran"
1318         noconfigdirs="$noconfigdirs target-boehm-gc";;
1319       *-*-linux*)
1320         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
1321       *)
1322         unsupported_languages="$unsupported_languages fortran"
1323         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
1324     esac
1325     ;;
1326   crx-*-*)
1327     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
1328     ;;
1329   d10v-*-*)
1330     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1331     ;;
1332   d30v-*-*)
1333     noconfigdirs="$noconfigdirs ${libgcj} gdb"
1334     ;;
1335   fr30-*-elf*)
1336     noconfigdirs="$noconfigdirs ${libgcj} gdb"
1337     ;;
1338   frv-*-*)
1339     noconfigdirs="$noconfigdirs ${libgcj}"
1340     ;;
1341   h8300*-*-*)
1342     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1343     ;;
1344   h8500-*-*)
1345     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1346     ;;
1347   hppa1.1-*-osf* | hppa1.1-*-bsd* )
1348     ;;
1349   hppa*64*-*-linux* | parisc*64*-*-linux*)
1350     # In this case, it's because the hppa64-linux target is for
1351     # the kernel only at this point and has no libc, and thus no
1352     # headers, crt*.o, etc., all of which are needed by these.
1353     noconfigdirs="$noconfigdirs target-zlib"
1354     ;;
1355   parisc*-*-linux* | hppa*-*-linux*)
1356     ;;
1357   hppa*-*-*elf* | \
1358   hppa*-*-lites* | \
1359   hppa*-*-openbsd* | \
1360   hppa*64*-*-*)
1361     noconfigdirs="$noconfigdirs ${libgcj}"
1362     ;;
1363   hppa*-*-*)
1364     # According to Alexandre Oliva <[email protected]>, libjava won't
1365     # build on HP-UX 10.20.
1366     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
1367     ;;
1368   i960-*-*)
1369     noconfigdirs="$noconfigdirs ${libgcj} gdb"
1370     ;;
1371   ia64*-*-elf*)
1372     # No gdb support yet.
1373     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
1374     ;;
1375   ia64*-**-hpux*)
1376     # No gdb or ld support yet.
1377     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
1378     ;;
1379   i370-*-opened*)
1380     ;;
1381   i[3456789]86-*-coff | i[3456789]86-*-elf)
1382     noconfigdirs="$noconfigdirs ${libgcj}"
1383     ;;
1384   i[3456789]86-*-linux*)
1385     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
1386     # not build java stuff by default.
1387     case "${target}" in
1388       *-*-*libc1*)
1389         noconfigdirs="$noconfigdirs ${libgcj}";;
1390     esac
1391
1392     # This section makes it possible to build newlib natively on linux.
1393     # If we are using a cross compiler then don't configure newlib.
1394     if test x${is_cross_compiler} != xno ; then
1395       noconfigdirs="$noconfigdirs target-newlib"
1396     fi
1397     noconfigdirs="$noconfigdirs target-libgloss"
1398     # If we are not using a cross compiler, do configure newlib.
1399     # Note however, that newlib will only be configured in this situation
1400     # if the --with-newlib option has been given, because otherwise
1401     # 'target-newlib' will appear in skipdirs.
1402     ;;
1403   i[3456789]86-*-mingw32*)
1404     target_configdirs="$target_configdirs target-mingw"
1405     noconfigdirs="$noconfigdirs expect target-libgloss ${libgcj}"
1406
1407     # Can't build gdb for mingw32 if not native.
1408     case "${host}" in
1409       i[3456789]86-*-mingw32) ;; # keep gdb tcl tk expect etc.
1410       *) noconfigdirs="$noconfigdirs gdb tcl tk expect itcl gnuserv"
1411          ;;
1412     esac
1413     ;;
1414   *-*-cygwin*)
1415     target_configdirs="$target_configdirs target-libtermcap target-winsup"
1416     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
1417     # always build newlib if winsup directory is present.
1418     if test -d "$srcdir/winsup"; then
1419       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
1420     elif test -d "$srcdir/newlib"; then
1421       echo "Warning: winsup is missing so newlib can't be built."
1422     fi
1423
1424     # Can't build gdb for Cygwin if not native.
1425     case "${host}" in
1426       *-*-cygwin*) ;; # keep gdb tcl tk expect etc.
1427       *) noconfigdirs="$noconfigdirs gdb tcl tk expect itcl libgui gnuserv"
1428          ;;
1429     esac
1430     ;;
1431   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
1432   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
1433     ;;
1434   i[3456789]86-*-pe)
1435     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
1436     ;;
1437   i[3456789]86-*-sco3.2v5*)
1438     # The linker does not yet know about weak symbols in COFF,
1439     # and is not configured to handle mixed ELF and COFF.
1440     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
1441     ;;
1442   i[3456789]86-*-sco*)
1443     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1444     ;;
1445   i[3456789]86-*-solaris2*)
1446     noconfigdirs="$noconfigdirs target-libgloss"
1447     ;;
1448   i[3456789]86-*-sysv4*)
1449     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1450     ;;
1451   i[3456789]86-*-beos*)
1452     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
1453     ;;
1454   i[3456789]86-*-rdos*)
1455     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
1456     ;;
1457   m32r-*-*)
1458     noconfigdirs="$noconfigdirs ${libgcj}"
1459     ;;
1460   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
1461     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
1462     ;;
1463   m68k-*-elf*)
1464     noconfigdirs="$noconfigdirs ${libgcj}"
1465     ;;
1466   m68k-*-coff*)
1467     noconfigdirs="$noconfigdirs ${libgcj}"
1468     ;;
1469   mcore-*-pe*)
1470   # The EPOC C++ environment does not support exceptions or rtti,
1471   # and so building libstdc++-v3 tends not to always work.
1472     noconfigdirs="$noconfigdirs target-libstdc++-v3"
1473     ;;
1474   mmix-*-*)
1475     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
1476     unsupported_languages="$unsupported_languages fortran java"
1477     ;;
1478   mn10200-*-*)
1479     noconfigdirs="$noconfigdirs ${libgcj}"
1480     ;;
1481   mn10300-*-*)
1482     noconfigdirs="$noconfigdirs ${libgcj}"
1483     ;;
1484   mt-*-*)
1485     noconfigdirs="$noconfigdirs sim"
1486     ;;
1487   powerpc-*-aix*)
1488     # copied from rs6000-*-* entry
1489     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
1490     ;;
1491   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
1492     target_configdirs="$target_configdirs target-winsup"
1493     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
1494     # always build newlib.
1495     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
1496     ;;
1497     # This is temporary until we can link against shared libraries
1498   powerpcle-*-solaris*)
1499     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
1500     ;;
1501   powerpc-*-beos*)
1502     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
1503     ;;
1504   powerpc-*-eabi)
1505     noconfigdirs="$noconfigdirs ${libgcj}"
1506     ;;
1507   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
1508     ;;
1509   rs6000-*-lynxos*)
1510     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
1511     ;;
1512   rs6000-*-aix*)
1513     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
1514     ;;
1515   rs6000-*-*)
1516     noconfigdirs="$noconfigdirs gprof ${libgcj}"
1517     ;;
1518   m68k-apollo-*)
1519     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
1520     ;;
1521   mips*-*-irix5*)
1522     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1523     ;;
1524   mips*-*-irix6*)
1525     # Linking libjava exceeds command-line length limits on at least
1526     # IRIX 6.2, but not on IRIX 6.5.
1527     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
1528     # <[email protected]>
1529     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1530     ;;
1531   mips*-dec-bsd*)
1532     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1533     ;;
1534   mips*-*-bsd*)
1535     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
1536     ;;
1537   mipstx39-*-*)
1538     noconfigdirs="$noconfigdirs gprof ${libgcj}"   # same as generic mips
1539     ;;
1540   mips64*-*-linux*)
1541     noconfigdirs="$noconfigdirs target-newlib ${libgcj}"
1542     ;;
1543   mips*-*-linux*)
1544     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1545     ;;
1546   mips*-*-*)
1547     noconfigdirs="$noconfigdirs gprof ${libgcj}"
1548     ;;
1549   romp-*-*)
1550     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
1551     ;;
1552   sh-*-* | sh64-*-*)
1553     case "${host}" in
1554       i[3456789]86-*-vsta) ;; # don't add gprof back in
1555       i[3456789]86-*-go32*) ;; # don't add gprof back in
1556       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
1557       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
1558     esac
1559     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1560     ;;
1561   sparc-*-elf*)
1562     noconfigdirs="$noconfigdirs ${libgcj}"
1563     ;;
1564   sparc64-*-elf*)
1565     noconfigdirs="$noconfigdirs ${libgcj}"
1566     ;;
1567   sparclite-*-*)
1568     noconfigdirs="$noconfigdirs ${libgcj}"
1569     ;;
1570   sparc-*-sunos4*)
1571     noconfigdirs="$noconfigdirs ${libgcj}"
1572     if test x${is_cross_compiler} != xno ; then
1573            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
1574     else
1575            use_gnu_ld=no
1576     fi
1577     ;;
1578   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
1579     noconfigdirs="$noconfigdirs ${libgcj}"
1580     ;;
1581   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
1582     ;;
1583   v810-*-*)
1584     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
1585     ;;
1586   v850-*-*)
1587     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1588     ;;
1589   v850e-*-*)
1590     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1591     ;;
1592   v850ea-*-*)
1593     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
1594     ;;
1595   vax-*-vms)
1596     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
1597     ;;
1598   vax-*-*)
1599     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1600     ;;
1601   xtensa-*-*)
1602     noconfigdirs="$noconfigdirs ${libgcj}"
1603     ;;
1604   ip2k-*-*)
1605     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
1606     ;;
1607   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
1608     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
1609     ;;
1610   *-*-lynxos*)
1611     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
1612     ;;
1613   *-*-*)
1614     noconfigdirs="$noconfigdirs ${libgcj}"
1615     ;;
1616 esac
1617
1618 # If we aren't building newlib, then don't build libgloss, since libgloss
1619 # depends upon some newlib header files.
1620 case "${noconfigdirs}" in
1621   *target-libgloss*) ;;
1622   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
1623 esac
1624
1625 # Work in distributions that contain no compiler tools, like Autoconf.
1626 tentative_cc=""
1627 host_makefile_frag=/dev/null
1628 if test -d ${srcdir}/config ; then
1629 case "${host}" in
1630   m68k-hp-hpux*)
1631     # Avoid "too much defining" errors from HPUX compiler.
1632     tentative_cc="cc -Wp,-H256000"
1633     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
1634     # If it's HP/UX ar, this should be harmless.
1635     RANLIB="ar ts"
1636     ;;
1637   m68k-apollo-sysv*)
1638     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
1639     ;;
1640   m68k-apollo-bsd*)
1641     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
1642     # chokes on bfd, the compiler won't let you assign integers to enums, and
1643     # other problems.  Defining CC to gcc is a questionable way to say "don't use
1644     # the apollo compiler" (the preferred version of GCC could be called cc,
1645     # or whatever), but I'm not sure leaving CC as cc is any better...
1646     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
1647     # Used to have BISON=yacc.
1648     tentative_cc=gcc
1649     ;;
1650   m88k-dg-dgux*)
1651     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
1652     ;;
1653   m88k-harris-cxux*)
1654     # Under CX/UX, we want to tell the compiler to use ANSI mode.
1655     tentative_cc="cc -Xa"
1656     host_makefile_frag="config/mh-cxux"
1657     ;;
1658   m88k-motorola-sysv*)
1659     ;;
1660   mips*-dec-ultrix*)
1661     tentative_cc="cc -Wf,-XNg1000"
1662     host_makefile_frag="config/mh-decstation"
1663     ;;
1664   mips*-nec-sysv4*)
1665     # The C compiler on NEC MIPS SVR4 needs bigger tables.
1666     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
1667     host_makefile_frag="config/mh-necv4"
1668     ;;
1669   mips*-sgi-irix4*)
1670     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
1671     # environment.  Also bump switch table size so that cp-parse will
1672     # compile.  Bump string length limit so linker builds.
1673     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
1674     ;;
1675   mips*-*-sysv4*)
1676     host_makefile_frag="config/mh-sysv4"
1677     ;;
1678   mips*-*-sysv*)
1679     # This is for a MIPS running RISC/os 4.52C.
1680
1681     # This is needed for GDB, but needs to be in the top-level make because
1682     # if a library is compiled with the bsd headers and gets linked with the
1683     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
1684     # a different size).
1685     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
1686     # known except to select the sysv environment.  Could we use /proc instead?
1687     # These "sysv environments" and "bsd environments" often end up being a pain.
1688     #
1689     # This is not part of CFLAGS because perhaps not all C compilers have this
1690     # option.
1691     tentative_cc="cc -systype sysv"
1692     ;;
1693   i370-ibm-opened*)
1694     tentative_cc="c89"
1695     ;;
1696   i[3456789]86-*-sysv5*)
1697     host_makefile_frag="config/mh-sysv5"
1698     ;;
1699   i[3456789]86-*-dgux*)
1700     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
1701     host_makefile_frag="config/mh-dgux386"
1702     ;;
1703   i[3456789]86-ncr-sysv4.3*)
1704     # The MetaWare compiler will generate a copyright message unless you
1705     # turn it off by adding the -Hnocopyr flag.
1706     tentative_cc="cc -Hnocopyr"
1707     ;;
1708   i[3456789]86-ncr-sysv4*)
1709     # for an NCR 3000 (i486/SVR4) system.
1710     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
1711     # This compiler not only emits obnoxious copyright messages every time
1712     # you run it, but it chokes and dies on a whole bunch of GNU source
1713     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
1714     tentative_cc="/usr/ccs/ATT/cc"
1715     host_makefile_frag="config/mh-ncr3000"
1716     ;;
1717   i[3456789]86-*-sco3.2v5*)
1718     ;;
1719   i[3456789]86-*-sco*)
1720     # The native C compiler botches some simple uses of const.  Unfortunately,
1721     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
1722     tentative_cc="cc -Dconst="
1723     host_makefile_frag="config/mh-sco"
1724     ;;
1725   i[3456789]86-*-udk*)
1726     host_makefile_frag="config/mh-sysv5"
1727     ;;
1728   i[3456789]86-*-solaris2*)
1729     host_makefile_frag="config/mh-sysv4"
1730     ;;
1731   i[3456789]86-*-msdosdjgpp*)
1732     host_makefile_frag="config/mh-djgpp"
1733     ;;
1734   *-cygwin*)
1735     host_makefile_frag="config/mh-cygwin"
1736     ;;
1737   *-mingw32*)
1738     ;;
1739   *-interix*)
1740     host_makefile_frag="config/mh-interix"
1741     ;;
1742   vax-*-ultrix2*)
1743     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
1744     tentative_cc=gcc
1745     ;;
1746   *-*-solaris2*)
1747     host_makefile_frag="config/mh-solaris"
1748     ;;
1749   m68k-sun-sunos*)
1750     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
1751     # without overflowing the jump tables (-J says to use a 32 bit table)
1752     tentative_cc="cc -J"
1753     ;;
1754   *-hp-hpux*)
1755     tentative_cc="cc -Wp,-H256000"
1756     ;;
1757   *-*-hiux*)
1758     tentative_cc="cc -Wp,-H256000"
1759     ;;
1760   rs6000-*-lynxos*)
1761     # /bin/cc is less than useful for our purposes.  Always use GCC
1762     tentative_cc="/usr/cygnus/progressive/bin/gcc"
1763     host_makefile_frag="config/mh-lynxrs6k"
1764     ;;
1765   powerpc-*-darwin*)
1766     host_makefile_frag="config/mh-ppc-darwin"
1767     ;;
1768   powerpc-*-aix*)
1769     host_makefile_frag="config/mh-ppc-aix"
1770     ;;
1771   rs6000-*-aix*)
1772     host_makefile_frag="config/mh-ppc-aix"
1773     ;;
1774   *-*-lynxos*)
1775     # /bin/cc is less than useful for our purposes.  Always use GCC
1776     tentative_cc="/bin/gcc"
1777     ;;
1778   *-*-sysv4*)
1779     host_makefile_frag="config/mh-sysv4"
1780     ;;
1781   # This is placed last to prevent interfering with the cases above.
1782   i[3456789]86-*-*)
1783     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
1784     host_makefile_frag="config/mh-x86omitfp"
1785     ;;
1786 esac
1787 fi
1788
1789 # If we aren't going to be using gcc, see if we can extract a definition
1790 # of CC from the fragment.
1791 # Actually, use the 'pre-extracted' version above.
1792 if test -z "${CC}" && test "${build}" = "${host}" ; then
1793   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1794   found=
1795   for dir in $PATH; do
1796     test -z "$dir" && dir=.
1797     if test -f $dir/gcc; then
1798       found=yes
1799       break
1800     fi
1801   done
1802   IFS="$save_ifs"
1803   if test -z "${found}" && test -n "${tentative_cc}" ; then
1804     CC=$tentative_cc
1805   fi
1806 fi
1807
1808 if test "${build}" != "${host}" ; then
1809   # If we are doing a Canadian Cross, in which the host and build systems
1810   # are not the same, we set reasonable default values for the tools.
1811
1812   CC=${CC-${host_alias}-gcc}
1813   CFLAGS=${CFLAGS-"-g -O2"}
1814   CXX=${CXX-${host_alias}-c++}
1815   CXXFLAGS=${CXXFLAGS-"-g -O2"}
1816   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
1817   BUILD_PREFIX=${build_alias}-
1818   BUILD_PREFIX_1=${build_alias}-
1819
1820 else
1821   # Set reasonable default values for some tools even if not Canadian.
1822   # Of course, these are different reasonable default values, originally
1823   # specified directly in the Makefile.
1824   # We don't export, so that autoconf can do its job.
1825   # Note that all these settings are above the fragment inclusion point
1826   # in Makefile.in, so can still be overridden by fragments.
1827   # This is all going to change when we autoconfiscate...
1828
1829   CC_FOR_BUILD="\$(CC)"
1830   BUILD_PREFIX=
1831   BUILD_PREFIX_1=loser-
1832
1833   # Extract the first word of "gcc", so it can be a program name with args.
1834 set dummy gcc; ac_word=$2
1835 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1836 echo "configure:1837: checking for $ac_word" >&5
1837 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1838   echo $ac_n "(cached) $ac_c" 1>&6
1839 else
1840   if test -n "$CC"; then
1841   ac_cv_prog_CC="$CC" # Let the user override the test.
1842 else
1843   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1844   ac_dummy="$PATH"
1845   for ac_dir in $ac_dummy; do
1846     test -z "$ac_dir" && ac_dir=.
1847     if test -f $ac_dir/$ac_word; then
1848       ac_cv_prog_CC="gcc"
1849       break
1850     fi
1851   done
1852   IFS="$ac_save_ifs"
1853 fi
1854 fi
1855 CC="$ac_cv_prog_CC"
1856 if test -n "$CC"; then
1857   echo "$ac_t""$CC" 1>&6
1858 else
1859   echo "$ac_t""no" 1>&6
1860 fi
1861
1862 if test -z "$CC"; then
1863   # Extract the first word of "cc", so it can be a program name with args.
1864 set dummy cc; ac_word=$2
1865 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1866 echo "configure:1867: checking for $ac_word" >&5
1867 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1868   echo $ac_n "(cached) $ac_c" 1>&6
1869 else
1870   if test -n "$CC"; then
1871   ac_cv_prog_CC="$CC" # Let the user override the test.
1872 else
1873   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1874   ac_prog_rejected=no
1875   ac_dummy="$PATH"
1876   for ac_dir in $ac_dummy; do
1877     test -z "$ac_dir" && ac_dir=.
1878     if test -f $ac_dir/$ac_word; then
1879       if test "$ac_dir/$ac_word" = "/usr/ucb/cc"; then
1880         ac_prog_rejected=yes
1881         continue
1882       fi
1883       ac_cv_prog_CC="cc"
1884       break
1885     fi
1886   done
1887   IFS="$ac_save_ifs"
1888 if test $ac_prog_rejected = yes; then
1889   # We found a bogon in the path, so make sure we never use it.
1890   set dummy $ac_cv_prog_CC
1891   shift
1892   if test $# -gt 0; then
1893     # We chose a different compiler from the bogus one.
1894     # However, it has the same basename, so the bogon will be chosen
1895     # first if we set CC to just the basename; use the full file name.
1896     shift
1897     set dummy "$ac_dir/$ac_word" "$@"
1898     shift
1899     ac_cv_prog_CC="$@"
1900   fi
1901 fi
1902 fi
1903 fi
1904 CC="$ac_cv_prog_CC"
1905 if test -n "$CC"; then
1906   echo "$ac_t""$CC" 1>&6
1907 else
1908   echo "$ac_t""no" 1>&6
1909 fi
1910
1911   if test -z "$CC"; then
1912     case "`uname -s`" in
1913     *win32* | *WIN32*)
1914       # Extract the first word of "cl", so it can be a program name with args.
1915 set dummy cl; ac_word=$2
1916 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
1917 echo "configure:1918: checking for $ac_word" >&5
1918 if eval "test \"`echo '$''{'ac_cv_prog_CC'+set}'`\" = set"; then
1919   echo $ac_n "(cached) $ac_c" 1>&6
1920 else
1921   if test -n "$CC"; then
1922   ac_cv_prog_CC="$CC" # Let the user override the test.
1923 else
1924   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
1925   ac_dummy="$PATH"
1926   for ac_dir in $ac_dummy; do
1927     test -z "$ac_dir" && ac_dir=.
1928     if test -f $ac_dir/$ac_word; then
1929       ac_cv_prog_CC="cl"
1930       break
1931     fi
1932   done
1933   IFS="$ac_save_ifs"
1934 fi
1935 fi
1936 CC="$ac_cv_prog_CC"
1937 if test -n "$CC"; then
1938   echo "$ac_t""$CC" 1>&6
1939 else
1940   echo "$ac_t""no" 1>&6
1941 fi
1942  ;;
1943     esac
1944   fi
1945   test -z "$CC" && { echo "configure: error: no acceptable cc found in \$PATH" 1>&2; exit 1; }
1946 fi
1947
1948 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works""... $ac_c" 1>&6
1949 echo "configure:1950: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) works" >&5
1950
1951 ac_ext=c
1952 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
1953 ac_cpp='$CPP $CPPFLAGS'
1954 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
1955 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
1956 cross_compiling=$ac_cv_prog_cc_cross
1957
1958 cat > conftest.$ac_ext << EOF
1959
1960 #line 1961 "configure"
1961 #include "confdefs.h"
1962
1963 main(){return(0);}
1964 EOF
1965 if { (eval echo configure:1966: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
1966   ac_cv_prog_cc_works=yes
1967   # If we can't run a trivial program, we are probably using a cross compiler.
1968   if (./conftest; exit) 2>/dev/null; then
1969     ac_cv_prog_cc_cross=no
1970   else
1971     ac_cv_prog_cc_cross=yes
1972   fi
1973 else
1974   echo "configure: failed program was:" >&5
1975   cat conftest.$ac_ext >&5
1976   ac_cv_prog_cc_works=no
1977 fi
1978 rm -fr conftest*
1979 ac_ext=c
1980 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
1981 ac_cpp='$CPP $CPPFLAGS'
1982 ac_compile='${CC-cc} -c $CFLAGS $CPPFLAGS conftest.$ac_ext 1>&5'
1983 ac_link='${CC-cc} -o conftest${ac_exeext} $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS 1>&5'
1984 cross_compiling=$ac_cv_prog_cc_cross
1985
1986 echo "$ac_t""$ac_cv_prog_cc_works" 1>&6
1987 if test $ac_cv_prog_cc_works = no; then
1988   { echo "configure: error: installation or configuration problem: C compiler cannot create executables." 1>&2; exit 1; }
1989 fi
1990 echo $ac_n "checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler""... $ac_c" 1>&6
1991 echo "configure:1992: checking whether the C compiler ($CC $CFLAGS $LDFLAGS) is a cross-compiler" >&5
1992 echo "$ac_t""$ac_cv_prog_cc_cross" 1>&6
1993 cross_compiling=$ac_cv_prog_cc_cross
1994
1995 echo $ac_n "checking whether we are using GNU C""... $ac_c" 1>&6
1996 echo "configure:1997: checking whether we are using GNU C" >&5
1997 if eval "test \"`echo '$''{'ac_cv_prog_gcc'+set}'`\" = set"; then
1998   echo $ac_n "(cached) $ac_c" 1>&6
1999 else
2000   cat > conftest.c <<EOF
2001 #ifdef __GNUC__
2002   yes;
2003 #endif
2004 EOF
2005 if { ac_try='${CC-cc} -E conftest.c'; { (eval echo configure:2006: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }; } | egrep yes >/dev/null 2>&1; then
2006   ac_cv_prog_gcc=yes
2007 else
2008   ac_cv_prog_gcc=no
2009 fi
2010 fi
2011
2012 echo "$ac_t""$ac_cv_prog_gcc" 1>&6
2013
2014 if test $ac_cv_prog_gcc = yes; then
2015   GCC=yes
2016 else
2017   GCC=
2018 fi
2019
2020 ac_test_CFLAGS="${CFLAGS+set}"
2021 ac_save_CFLAGS="$CFLAGS"
2022 CFLAGS=
2023 echo $ac_n "checking whether ${CC-cc} accepts -g""... $ac_c" 1>&6
2024 echo "configure:2025: checking whether ${CC-cc} accepts -g" >&5
2025 if eval "test \"`echo '$''{'ac_cv_prog_cc_g'+set}'`\" = set"; then
2026   echo $ac_n "(cached) $ac_c" 1>&6
2027 else
2028   echo 'void f(){}' > conftest.c
2029 if test -z "`${CC-cc} -g -c conftest.c 2>&1`"; then
2030   ac_cv_prog_cc_g=yes
2031 else
2032   ac_cv_prog_cc_g=no
2033 fi
2034 rm -f conftest*
2035
2036 fi
2037
2038 echo "$ac_t""$ac_cv_prog_cc_g" 1>&6
2039 if test "$ac_test_CFLAGS" = set; then
2040   CFLAGS="$ac_save_CFLAGS"
2041 elif test $ac_cv_prog_cc_g = yes; then
2042   if test "$GCC" = yes; then
2043     CFLAGS="-g -O2"
2044   else
2045     CFLAGS="-g"
2046   fi
2047 else
2048   if test "$GCC" = yes; then
2049     CFLAGS="-O2"
2050   else
2051     CFLAGS=
2052   fi
2053 fi
2054
2055
2056   # We must set the default linker to the linker used by gcc for the correct
2057   # operation of libtool.  If LD is not defined and we are using gcc, try to
2058   # set the LD default to the ld used by gcc.
2059   if test -z "$LD"; then
2060     if test "$GCC" = yes; then
2061       case $build in
2062       *-*-mingw*)
2063         gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
2064       *)
2065         gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
2066       esac
2067       case $gcc_prog_ld in
2068       # Accept absolute paths.
2069       [\\/]* | [A-Za-z]:[\\/]*)
2070         LD="$gcc_prog_ld" ;;
2071       esac
2072     fi
2073   fi
2074
2075   CXX=${CXX-"c++"}
2076   CFLAGS=${CFLAGS-"-g"}
2077   CXXFLAGS=${CXXFLAGS-"-g -O2"}
2078 fi
2079
2080 if test $host != $build; then
2081   ac_tool_prefix=${host_alias}-
2082 else
2083   ac_tool_prefix=
2084 fi
2085
2086
2087
2088 # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
2089 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
2090 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2091 echo "configure:2092: checking for $ac_word" >&5
2092 if eval "test \"`echo '$''{'ac_cv_prog_GNATBIND'+set}'`\" = set"; then
2093   echo $ac_n "(cached) $ac_c" 1>&6
2094 else
2095   if test -n "$GNATBIND"; then
2096   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
2097 else
2098   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2099   ac_dummy="$PATH"
2100   for ac_dir in $ac_dummy; do
2101     test -z "$ac_dir" && ac_dir=.
2102     if test -f $ac_dir/$ac_word; then
2103       ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
2104       break
2105     fi
2106   done
2107   IFS="$ac_save_ifs"
2108 fi
2109 fi
2110 GNATBIND="$ac_cv_prog_GNATBIND"
2111 if test -n "$GNATBIND"; then
2112   echo "$ac_t""$GNATBIND" 1>&6
2113 else
2114   echo "$ac_t""no" 1>&6
2115 fi
2116
2117
2118 if test -z "$ac_cv_prog_GNATBIND"; then
2119 if test -n "$ac_tool_prefix"; then
2120   # Extract the first word of "gnatbind", so it can be a program name with args.
2121 set dummy gnatbind; ac_word=$2
2122 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
2123 echo "configure:2124: checking for $ac_word" >&5
2124 if eval "test \"`echo '$''{'ac_cv_prog_GNATBIND'+set}'`\" = set"; then
2125   echo $ac_n "(cached) $ac_c" 1>&6
2126 else
2127   if test -n "$GNATBIND"; then
2128   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
2129 else
2130   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
2131   ac_dummy="$PATH"
2132   for ac_dir in $ac_dummy; do
2133     test -z "$ac_dir" && ac_dir=.
2134     if test -f $ac_dir/$ac_word; then
2135       ac_cv_prog_GNATBIND="gnatbind"
2136       break
2137     fi
2138   done
2139   IFS="$ac_save_ifs"
2140   test -z "$ac_cv_prog_GNATBIND" && ac_cv_prog_GNATBIND="no"
2141 fi
2142 fi
2143 GNATBIND="$ac_cv_prog_GNATBIND"
2144 if test -n "$GNATBIND"; then
2145   echo "$ac_t""$GNATBIND" 1>&6
2146 else
2147   echo "$ac_t""no" 1>&6
2148 fi
2149
2150 else
2151   GNATBIND="no"
2152 fi
2153 fi
2154
2155 echo $ac_n "checking whether compiler driver understands Ada""... $ac_c" 1>&6
2156 echo "configure:2157: checking whether compiler driver understands Ada" >&5
2157 if eval "test \"`echo '$''{'acx_cv_cc_gcc_supports_ada'+set}'`\" = set"; then
2158   echo $ac_n "(cached) $ac_c" 1>&6
2159 else
2160   cat >conftest.adb <<EOF
2161 procedure conftest is begin null; end conftest;
2162 EOF
2163 acx_cv_cc_gcc_supports_ada=no
2164 # There is a bug in old released versions of GCC which causes the
2165 # driver to exit successfully when the appropriate language module
2166 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
2167 # Therefore we must check for the error message as well as an
2168 # unsuccessful exit.
2169 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
2170 # given a .adb file, but produce no object file.  So we must check
2171 # if an object file was really produced to guard against this.
2172 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
2173 if test x"$errors" = x && test -f conftest.$ac_objext; then
2174   acx_cv_cc_gcc_supports_ada=yes
2175 fi
2176 rm -f conftest.*
2177 fi
2178
2179 echo "$ac_t""$acx_cv_cc_gcc_supports_ada" 1>&6
2180
2181 if test x$GNATBIND != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
2182   have_gnat=yes
2183 else
2184   have_gnat=no
2185 fi
2186
2187 echo $ac_n "checking how to compare bootstrapped objects""... $ac_c" 1>&6
2188 echo "configure:2189: checking how to compare bootstrapped objects" >&5
2189 if eval "test \"`echo '$''{'gcc_cv_prog_cmp_skip'+set}'`\" = set"; then
2190   echo $ac_n "(cached) $ac_c" 1>&6
2191 else
2192    echo abfoo >t1
2193   echo cdfoo >t2
2194   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
2195   if cmp t1 t2 2 2 > /dev/null 2>&1; then
2196     if cmp t1 t2 1 1 > /dev/null 2>&1; then
2197       :
2198     else
2199       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
2200     fi
2201   fi
2202   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
2203     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
2204       :
2205     else
2206       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
2207     fi
2208   fi
2209   rm t1 t2
2210
2211 fi
2212
2213 echo "$ac_t""$gcc_cv_prog_cmp_skip" 1>&6
2214 do_compare="$gcc_cv_prog_cmp_skip"
2215
2216
2217
2218 # Check for GMP and MPFR
2219 gmplibs=
2220 gmpinc=
2221 have_gmp=yes
2222 # Specify a location for mpfr
2223 # check for this first so it ends up on the link line before gmp.
2224 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
2225 if test "${with_mpfr_dir+set}" = set; then
2226   withval="$with_mpfr_dir"
2227   :
2228 fi
2229
2230
2231 if test "x$with_mpfr_dir" != x; then
2232   gmpinc="-I$with_mpfr_dir"
2233   gmplibs="$with_mpfr_dir/libmpfr.a"
2234 else
2235   gmplibs="-lmpfr"
2236 fi
2237
2238 # Check whether --with-mpfr or --without-mpfr was given.
2239 if test "${with_mpfr+set}" = set; then
2240   withval="$with_mpfr"
2241   :
2242 fi
2243
2244
2245 if test "x$with_mpfr" != x; then
2246   gmplibs="-L$with_mpfr/lib $gmplibs"
2247   gmpinc="-I$with_mpfr/include"
2248 fi
2249
2250 # Specify a location for gmp
2251 # Check whether --with-gmp-dir or --without-gmp-dir was given.
2252 if test "${with_gmp_dir+set}" = set; then
2253   withval="$with_gmp_dir"
2254   :
2255 fi
2256
2257
2258 if test "x$with_gmp_dir" != x; then
2259   gmpinc="$gmpinc -I$with_gmp_dir"
2260   if test -f "$with_gmp_dir/.libs/libgmp.a"; then
2261     gmplibs="$gmplibs $with_gmp_dir/.libs/libgmp.a"
2262   elif test -f "$with_gmp_dir/_libs/libgmp.a"; then
2263     gmplibs="$gmplibs $with_gmp_dir/_libs/libgmp.a"
2264   fi
2265   # One of the later tests will catch the error if neither library is present.
2266 else
2267   gmplibs="$gmplibs -lgmp"
2268 fi
2269
2270 # Check whether --with-gmp or --without-gmp was given.
2271 if test "${with_gmp+set}" = set; then
2272   withval="$with_gmp"
2273   :
2274 fi
2275
2276
2277 if test "x$with_gmp" != x; then
2278   gmplibs="-L$with_gmp/lib $gmplibs"
2279   gmpinc="-I$with_gmp/include $gmpinc"
2280 fi
2281
2282 saved_CFLAGS="$CFLAGS"
2283 CFLAGS="$CFLAGS $gmpinc"
2284 # Check GMP actually works
2285 echo $ac_n "checking for correct version of gmp.h""... $ac_c" 1>&6
2286 echo "configure:2287: checking for correct version of gmp.h" >&5
2287 cat > conftest.$ac_ext <<EOF
2288 #line 2289 "configure"
2289 #include "confdefs.h"
2290 #include "gmp.h"
2291 int main() {
2292
2293 #if __GNU_MP_VERSION < 3
2294 choke me
2295 #endif
2296
2297 ; return 0; }
2298 EOF
2299 if { (eval echo configure:2300: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
2300   rm -rf conftest*
2301   echo "$ac_t""yes" 1>&6
2302 else
2303   echo "configure: failed program was:" >&5
2304   cat conftest.$ac_ext >&5
2305   rm -rf conftest*
2306   echo "$ac_t""no" 1>&6; have_gmp=no
2307 fi
2308 rm -f conftest*
2309
2310 if test x"$have_gmp" = xyes; then
2311   echo $ac_n "checking for MPFR""... $ac_c" 1>&6
2312 echo "configure:2313: checking for MPFR" >&5
2313
2314   saved_LIBS="$LIBS"
2315   LIBS="$LIBS $gmplibs"
2316   cat > conftest.$ac_ext <<EOF
2317 #line 2318 "configure"
2318 #include "confdefs.h"
2319 #include <gmp.h>
2320 #include <mpfr.h>
2321 int main() {
2322 mpfr_t n; mpfr_init(n);
2323 ; return 0; }
2324 EOF
2325 if { (eval echo configure:2326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
2326   rm -rf conftest*
2327   echo "$ac_t""yes" 1>&6
2328 else
2329   echo "configure: failed program was:" >&5
2330   cat conftest.$ac_ext >&5
2331   rm -rf conftest*
2332   echo "$ac_t""no" 1>&6; have_gmp=no
2333 fi
2334 rm -f conftest*
2335   LIBS="$saved_LIBS"
2336   CFLAGS="$saved_CFLAGS"
2337 fi
2338
2339 # Flags needed for both GMP and/or MPFR
2340
2341
2342
2343 # By default, C is the only stage 1 language.
2344 stage1_languages=c
2345
2346
2347 # Figure out what language subdirectories are present.
2348 # Look if the user specified --enable-languages="..."; if not, use
2349 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2350 # go away some day.
2351 # NB:  embedded tabs in this IF block -- do not untabify
2352 if test -d ${srcdir}/gcc; then
2353   if test x"${enable_languages+set}" != xset; then
2354     if test x"${LANGUAGES+set}" = xset; then
2355       enable_languages="${LANGUAGES}"
2356         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
2357     else
2358       enable_languages=all
2359     fi
2360   else
2361     if test x"${enable_languages}" = x ||
2362        test x"${enable_languages}" = xyes;
2363        then
2364       echo configure.in: --enable-languages needs at least one language argument 1>&2
2365       exit 1
2366     fi
2367   fi
2368   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
2369
2370   # 'f95' is the old name for the 'fortran' language. We issue a warning
2371   # and make the substitution.
2372   case ,${enable_languages}, in
2373     *,f95,*)
2374       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
2375       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
2376       ;;
2377   esac
2378
2379   # First scan to see if an enabled language requires some other language.
2380   # We assume that a given config-lang.in will list all the language
2381   # front ends it requires, even if some are required indirectly.
2382   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
2383     case ${lang_frag} in
2384       ..) ;;
2385       # The odd quoting in the next line works around
2386       # an apparent bug in bash 1.12 on linux.
2387       ${srcdir}/gcc/[*]/config-lang.in) ;;
2388       *)
2389         # From the config-lang.in, get $language, $lang_requires
2390         language=
2391         lang_requires=
2392         . ${lang_frag}
2393         for other in ${lang_requires} ; do
2394           case ,${enable_languages}, in
2395             *,$other,*) ;;
2396             *,all,*) ;;
2397             *,$language,*)
2398               echo " \`$other' language required by \`$language'; enabling" 1>&2
2399               enable_languages="${enable_languages},${other}"
2400               ;;
2401           esac
2402         done
2403         ;;
2404     esac
2405   done
2406
2407   new_enable_languages=c
2408   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
2409   potential_languages=c
2410
2411   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
2412     case ${lang_frag} in
2413       ..) ;;
2414       # The odd quoting in the next line works around
2415       # an apparent bug in bash 1.12 on linux.
2416       ${srcdir}/gcc/[*]/config-lang.in) ;;
2417       *)
2418         # From the config-lang.in, get $language, $target_libs,
2419         # $lang_dirs, $boot_language, and $build_by_default
2420         language=
2421         target_libs=
2422         lang_dirs=
2423         boot_language=
2424         build_by_default=
2425         need_gmp=
2426         . ${lang_frag}
2427         potential_languages="${potential_languages},${language}"
2428         # This is quite sensitive to the ordering of the case statement arms.
2429         case ,${enable_languages},:${language}:${have_gnat}:${build_by_default} in
2430           *::*:*)
2431             echo "${lang_frag} doesn't set \$language." 1>&2
2432             exit 1
2433             ;;
2434           *:ada:no:*)
2435             # Ada was requested with no preexisting GNAT.  Disable unconditionally.
2436             add_this_lang=no
2437             ;;
2438           *,${language},*:*:*:*)
2439             # Language was explicitly selected; include it.
2440             add_this_lang=yes
2441             ;;
2442           *,all,*:*:*:no)
2443             # 'all' was selected, but this is not a default language
2444             # so do not include it.
2445             add_this_lang=no
2446             ;;
2447           *,all,*:*:*:*)
2448             # 'all' was selected and this is a default language; include it.
2449             add_this_lang=yes
2450             ;;
2451           *)
2452             add_this_lang=no
2453             ;;
2454         esac
2455
2456         # Disable languages that need GMP if it isn't available.
2457         case ,${enable_languages},:${have_gmp}:${need_gmp} in
2458           *,${language},*:no:yes)
2459             # Specifically requested language; tell them.
2460             { echo "configure: error: GMP with MPFR support is required to build $language" 1>&2; exit 1; }
2461             ;;
2462           *:no:yes)
2463             # Silently disable.
2464             add_this_lang=no
2465             ;;
2466         esac
2467
2468         # Disable a language that is unsupported by the target.
2469         case " $unsupported_languages " in
2470           *" $language "*)
2471             add_this_lang=no
2472             ;;
2473         esac
2474
2475         case $add_this_lang in
2476           no)
2477             # Remove language-dependent dirs.
2478             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
2479             ;;
2480           *)
2481             new_enable_languages="$new_enable_languages,$language"
2482             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
2483             case ${boot_language} in
2484               yes)
2485                 # Add to (comma-separated) list of stage 1 languages.
2486                 stage1_languages="${stage1_languages},${language}"
2487                 ;;
2488             esac
2489             ;;
2490         esac
2491         ;;
2492     esac
2493   done
2494
2495   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
2496   if test "x$missing_languages" != x; then
2497     { echo "configure: error:
2498 The following requested languages could not be built: ${missing_languages}
2499 Recognised languages are: ${potential_languages}" 1>&2; exit 1; }
2500   fi
2501
2502   if test "x$new_enable_languages" != "x$enable_languages"; then
2503     echo The following languages will be built: ${new_enable_languages}
2504   fi
2505   enable_languages="$new_enable_languages"
2506   ac_configure_args=`echo " $ac_configure_args" | sed -e 's/ --enable-languages=[^ ]*//' -e 's/$/ --enable-languages='"$enable_languages"/ `
2507 fi
2508
2509 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
2510 # $build_configdirs and $target_configdirs.
2511 # If we have the source for $noconfigdirs entries, add them to $notsupp.
2512
2513 notsupp=""
2514 for dir in . $skipdirs $noconfigdirs ; do
2515   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
2516   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2517     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
2518     if test -r $srcdir/$dirname/configure ; then
2519       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2520         true
2521       else
2522         notsupp="$notsupp $dir"
2523       fi
2524     fi
2525   fi
2526   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2527     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
2528     if test -r $srcdir/$dirname/configure ; then
2529       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2530         true
2531       else
2532         notsupp="$notsupp $dir"
2533       fi
2534     fi
2535   fi
2536   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2537     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
2538     if test -r $srcdir/$dirname/configure ; then
2539       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2540         true
2541       else
2542         notsupp="$notsupp $dir"
2543       fi
2544     fi
2545   fi
2546 done
2547
2548 # Sometimes the tools are distributed with libiberty but with no other
2549 # libraries.  In that case, we don't want to build target-libiberty.
2550 if test -n "${target_configdirs}" ; then
2551   others=
2552   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
2553     if test "$i" != "libiberty" ; then
2554       if test -r $srcdir/$i/configure ; then
2555         others=yes;
2556         break;
2557       fi
2558     fi
2559   done
2560   if test -z "${others}" ; then
2561     target_configdirs=
2562   fi
2563 fi
2564
2565 # Quietly strip out all directories which aren't configurable in this tree.
2566 # This relies on all configurable subdirectories being autoconfiscated, which
2567 # is now the case.
2568 build_configdirs_all="$build_configdirs"
2569 build_configdirs=
2570 for i in ${build_configdirs_all} ; do
2571   j=`echo $i | sed -e s/build-//g`
2572   if test -f ${srcdir}/$j/configure ; then
2573     build_configdirs="${build_configdirs} $i"
2574   fi
2575 done
2576
2577 configdirs_all="$configdirs"
2578 configdirs=
2579 for i in ${configdirs_all} ; do
2580   if test -f ${srcdir}/$i/configure ; then
2581     configdirs="${configdirs} $i"
2582   fi
2583 done
2584
2585 target_configdirs_all="$target_configdirs"
2586 target_configdirs=
2587 for i in ${target_configdirs_all} ; do
2588   j=`echo $i | sed -e s/target-//g`
2589   if test -f ${srcdir}/$j/configure ; then
2590     target_configdirs="${target_configdirs} $i"
2591   fi
2592 done
2593
2594 # Produce a warning message for the subdirs we can't configure.
2595 # This isn't especially interesting in the Cygnus tree, but in the individual
2596 # FSF releases, it's important to let people know when their machine isn't
2597 # supported by the one or two programs in a package.
2598
2599 if test -n "${notsupp}" && test -z "${norecursion}" ; then
2600   # If $appdirs is non-empty, at least one of those directories must still
2601   # be configured, or we error out.  (E.g., if the gas release supports a
2602   # specified target in some subdirs but not the gas subdir, we shouldn't
2603   # pretend that all is well.)
2604   if test -n "$appdirs" ; then
2605     for dir in $appdirs ; do
2606       if test -r $dir/Makefile.in ; then
2607         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
2608           appdirs=""
2609           break
2610         fi
2611         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
2612           appdirs=""
2613           break
2614         fi
2615       fi
2616     done
2617     if test -n "$appdirs" ; then
2618       echo "*** This configuration is not supported by this package." 1>&2
2619       exit 1
2620     fi
2621   fi
2622   # Okay, some application will build, or we don't care to check.  Still
2623   # notify of subdirs not getting built.
2624   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
2625   echo "    ${notsupp}" 1>&2
2626   echo "    (Any other directories should still work fine.)" 1>&2
2627 fi
2628
2629 case "$host" in
2630   *msdosdjgpp*)
2631     enable_gdbtk=no ;;
2632 esac
2633
2634 copy_dirs=
2635
2636 # Check whether --with-build-sysroot or --without-build-sysroot was given.
2637 if test "${with_build_sysroot+set}" = set; then
2638   withval="$with_build_sysroot"
2639   if test x"$withval" != x ; then
2640      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
2641    fi
2642 else
2643   SYSROOT_CFLAGS_FOR_TARGET=
2644 fi
2645
2646
2647
2648 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
2649 # the named directory are copied to $(tooldir)/sys-include.
2650 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
2651   if test x${is_cross_compiler} = xno ; then
2652     echo 1>&2 '***' --with-headers is only supported when cross compiling
2653     exit 1
2654   fi
2655   if test x"${with_headers}" != xyes ; then
2656     case "${exec_prefixoption}" in
2657     "") x=${prefix} ;;
2658     *) x=${exec_prefix} ;;
2659     esac
2660     copy_dirs="${copy_dirs} ${with_headers} $x/${target_alias}/sys-include"
2661   fi
2662 fi
2663
2664 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
2665 # the name directories are copied to $(tooldir)/lib.  Multiple directories
2666 # are permitted.
2667 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2668   if test x${is_cross_compiler} = xno ; then
2669     echo 1>&2 '***' --with-libs is only supported when cross compiling
2670     exit 1
2671   fi
2672   if test x"${with_libs}" != xyes ; then
2673     # Copy the libraries in reverse order, so that files in the first named
2674     # library override files in subsequent libraries.
2675     case "${exec_prefixoption}" in
2676     "") x=${prefix} ;;
2677     *) x=${exec_prefix} ;;
2678     esac
2679     for l in ${with_libs}; do
2680       copy_dirs="$l $x/${target_alias}/lib ${copy_dirs}"
2681     done
2682   fi
2683 fi
2684
2685 # Set with_gnu_as and with_gnu_ld as appropriate.
2686 #
2687 # This is done by determining whether or not the appropriate directory
2688 # is available, and by checking whether or not specific configurations
2689 # have requested that this magic not happen.
2690 #
2691 # The command line options always override the explicit settings in
2692 # configure.in, and the settings in configure.in override this magic.
2693 #
2694 # If the default for a toolchain is to use GNU as and ld, and you don't
2695 # want to do that, then you should use the --without-gnu-as and
2696 # --without-gnu-ld options for the configure script.
2697
2698 if test x${use_gnu_as} = x &&
2699    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
2700   with_gnu_as=yes
2701   extra_host_args="$extra_host_args --with-gnu-as"
2702 fi
2703
2704 if test x${use_gnu_ld} = x &&
2705    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
2706   with_gnu_ld=yes
2707   extra_host_args="$extra_host_args --with-gnu-ld"
2708 fi
2709
2710 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
2711 # can detect this case.
2712
2713 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
2714   with_newlib=yes
2715   extra_host_args="$extra_host_args --with-newlib"
2716 fi
2717
2718 # Handle ${copy_dirs}
2719 set fnord ${copy_dirs}
2720 shift
2721 while test $# != 0 ; do
2722   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
2723     :
2724   else
2725     echo Copying $1 to $2
2726
2727     # Use the install script to create the directory and all required
2728     # parent directories.
2729     if test -d $2 ; then
2730       :
2731     else
2732       echo >config.temp
2733       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
2734     fi
2735
2736     # Copy the directory, assuming we have tar.
2737     # FIXME: Should we use B in the second tar?  Not all systems support it.
2738     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
2739
2740     # It is the responsibility of the user to correctly adjust all
2741     # symlinks.  If somebody can figure out how to handle them correctly
2742     # here, feel free to add the code.
2743
2744     echo $1 > $2/COPIED
2745   fi
2746   shift; shift
2747 done
2748
2749 # Determine a target-dependent exec_prefix that the installed
2750 # gcc will search in.  Keep this list sorted by triplet, with
2751 # the *-*-osname triplets last.
2752 md_exec_prefix=
2753 case "${target}" in
2754   alpha*-*-*vms*)
2755     md_exec_prefix=/gnu/lib/gcc-lib
2756     ;;
2757   i3456786-pc-msdosdjgpp*)
2758     md_exec_prefix=/dev/env/DJDIR/bin
2759     ;;
2760   i3456786-*-sco3.2v5*)
2761     if test $with_gnu_as = yes; then
2762       md_exec_prefix=/usr/gnu/bin
2763     else
2764       md_exec_prefix=/usr/ccs/bin/elf
2765     fi
2766     ;;
2767
2768   mn10300-*-* | \
2769   powerpc-*-chorusos* | \
2770   powerpc*-*-eabi* | \
2771   powerpc*-*-sysv* | \
2772   powerpc*-*-kaos* | \
2773   s390x-ibm-tpf*)
2774     md_exec_prefix=/usr/ccs/bin
2775     ;;
2776   sparc64-*-elf*)
2777     ;;
2778   v850*-*-*)
2779     md_exec_prefix=/usr/ccs/bin
2780     ;;
2781   xtensa-*-elf*)
2782     ;;
2783
2784   *-*-beos* | \
2785   *-*-elf* | \
2786   *-*-hpux* | \
2787   *-*-netware* | \
2788   *-*-nto-qnx* | \
2789   *-*-rtems* | \
2790   *-*-solaris2* | \
2791   *-*-sysv45* | \
2792   *-*-vxworks* | \
2793   *-wrs-windiss)
2794     md_exec_prefix=/usr/ccs/bin
2795     ;;
2796 esac
2797
2798 extra_arflags_for_target=
2799 extra_nmflags_for_target=
2800 extra_ranlibflags_for_target=
2801 target_makefile_frag=/dev/null
2802 case "${target}" in
2803   *-*-netware*)
2804     target_makefile_frag="config/mt-netware"
2805     ;;
2806   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2807     target_makefile_frag="config/mt-gnu"
2808     ;;
2809   *-*-aix4.[3456789]* | *-*-aix[56789].*)
2810     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
2811     # commands to handle both 32-bit and 64-bit objects.  These flags are
2812     # harmless if we're using GNU nm or ar.
2813     extra_arflags_for_target=" -X32_64"
2814     extra_nmflags_for_target=" -B -X32_64"
2815     ;;
2816   *-*-darwin*)
2817     # ranlib from Darwin requires the -c flag to look at common symbols.
2818     extra_ranlibflags_for_target=" -c"
2819     ;;
2820   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
2821     target_makefile_frag="config/mt-wince"
2822     ;;
2823 esac
2824
2825 alphaieee_frag=/dev/null
2826 case $target in
2827   alpha*-*-*)
2828     # This just makes sure to use the -mieee option to build target libs.
2829     # This should probably be set individually by each library.
2830     alphaieee_frag="config/mt-alphaieee"
2831     ;;
2832 esac
2833
2834 # If --enable-target-optspace always use -Os instead of -O2 to build
2835 # the target libraries, similarly if it is not specified, use -Os
2836 # on selected platforms.
2837 ospace_frag=/dev/null
2838 case "${enable_target_optspace}:${target}" in
2839   yes:*)
2840     ospace_frag="config/mt-ospace"
2841     ;;
2842   :d30v-*)
2843     ospace_frag="config/mt-d30v"
2844     ;;
2845   :m32r-* | :d10v-* | :fr30-*)
2846     ospace_frag="config/mt-ospace"
2847     ;;
2848   no:* | :*)
2849     ;;
2850   *)
2851     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
2852     ;;
2853 esac
2854
2855 # Default to using --with-stabs for certain targets.
2856 if test x${with_stabs} = x ; then
2857   case "${target}" in
2858   mips*-*-irix[56]*)
2859     ;;
2860   mips*-*-* | alpha*-*-osf*)
2861     with_stabs=yes;
2862     extra_host_args="${extra_host_args} --with-stabs"
2863     ;;
2864   esac
2865 fi
2866
2867 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
2868 # them automatically.
2869 case "${host}" in
2870   hppa*64*-*-hpux11*)
2871     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
2872     ;;
2873 esac
2874
2875 # Some systems (e.g., one of the i386-aix systems the gas testers are
2876 # using) don't handle "\$" correctly, so don't use it here.
2877 tooldir='${exec_prefix}'/${target_alias}
2878 build_tooldir=${tooldir}
2879
2880 # Create a .gdbinit file which runs the one in srcdir
2881 # and tells GDB to look there for source files.
2882
2883 if test -r ${srcdir}/.gdbinit ; then
2884   case ${srcdir} in
2885     .) ;;
2886     *) cat > ./.gdbinit <<EOF
2887 # ${NO_EDIT}
2888 dir ${srcdir}
2889 dir .
2890 source ${srcdir}/.gdbinit
2891 EOF
2892     ;;
2893   esac
2894 fi
2895
2896 # Make sure that the compiler is able to generate an executable.  If it
2897 # can't, we are probably in trouble.  We don't care whether we can run the
2898 # executable--we might be using a cross compiler--we only care whether it
2899 # can be created.  At this point the main configure script has set CC.
2900 we_are_ok=no
2901 echo "int main () { return 0; }" > conftest.c
2902 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
2903 if test $? = 0 ; then
2904   if test -s conftest || test -s conftest.exe ; then
2905     we_are_ok=yes
2906   fi
2907 fi
2908 case $we_are_ok in
2909   no)
2910     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
2911     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
2912     rm -f conftest*
2913     exit 1
2914     ;;
2915 esac
2916 rm -f conftest*
2917
2918 # The Solaris /usr/ucb/cc compiler does not appear to work.
2919 case "${host}" in
2920   sparc-sun-solaris2*)
2921       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
2922       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
2923           could_use=
2924           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
2925           if test -d /opt/cygnus/bin ; then
2926               if test "$could_use" = "" ; then
2927                   could_use="/opt/cygnus/bin"
2928               else
2929                   could_use="$could_use or /opt/cygnus/bin"
2930               fi
2931           fi
2932         if test "$could_use" = "" ; then
2933             echo "Warning: compilation may fail because you're using"
2934             echo "/usr/ucb/cc.  You should change your PATH or CC "
2935             echo "variable and rerun configure."
2936         else
2937             echo "Warning: compilation may fail because you're using"
2938             echo "/usr/ucb/cc, when you should use the C compiler from"
2939             echo "$could_use.  You should change your"
2940             echo "PATH or CC variable and rerun configure."
2941         fi
2942       fi
2943   ;;
2944 esac
2945
2946 case "${host}" in
2947   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
2948   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
2949   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
2950 esac
2951
2952 # Record target_configdirs and the configure arguments for target and
2953 # build configuration in Makefile.
2954 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
2955 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
2956
2957 # Determine whether gdb needs tk/tcl or not.
2958 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
2959 # and in that case we want gdb to be built without tk.  Ugh!
2960 # In fact I believe gdb is the *only* package directly dependent on tk,
2961 # so we should be able to put the 'maybe's in unconditionally and
2962 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
2963 # 100% sure that that's safe though.
2964
2965 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
2966 case "$enable_gdbtk" in
2967   no)
2968     GDB_TK="" ;;
2969   yes)
2970     GDB_TK="${gdb_tk}" ;;
2971   *)
2972     # Only add the dependency on gdbtk when GDBtk is part of the gdb
2973     # distro.  Eventually someone will fix this and move Insight, nee
2974     # gdbtk to a separate directory.
2975     if test -d ${srcdir}/gdb/gdbtk ; then
2976       GDB_TK="${gdb_tk}"
2977     else
2978       GDB_TK=""
2979     fi
2980     ;;
2981 esac
2982 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
2983 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
2984
2985 # Strip out unwanted targets.
2986
2987 # While at that, we remove Makefiles if we were started for recursive
2988 # configuration, so that the top-level Makefile reconfigures them,
2989 # like we used to do when configure itself was recursive.
2990
2991 # Loop over modules.  $extrasub must be used with care, limiting as
2992 # much as possible the usage of range addresses.  That's because autoconf
2993 # splits the sed script to overcome limits in the number of commands,
2994 # and relying on carefully-timed sed passes may turn out to be very hard
2995 # to maintain later.  In this particular case, you just have to be careful
2996 # not to nest @if/@endif pairs, because configure will not warn you at all.
2997
2998 # Check whether --enable-bootstrap or --disable-bootstrap was given.
2999 if test "${enable_bootstrap+set}" = set; then
3000   enableval="$enable_bootstrap"
3001   :
3002 else
3003   enable_bootstrap=default
3004 fi
3005
3006
3007 # Issue errors and warnings for invalid/strange bootstrap combinations.
3008 case "$configdirs" in
3009   *gcc*) have_compiler=yes ;;
3010   *) have_compiler=no ;;
3011 esac
3012
3013 case "$have_compiler:$host:$target:$enable_bootstrap" in
3014   *:*:*:no) ;;
3015
3016   # Default behavior.  Enable bootstrap if we have a compiler
3017   # and we are in a native configuration.
3018   yes:$build:$build:default)
3019     enable_bootstrap=yes ;;
3020
3021   *:*:*:default)
3022     enable_bootstrap=no ;;
3023
3024   # We have a compiler and we are in a native configuration, bootstrap is ok
3025   yes:$build:$build:yes)
3026     ;;
3027
3028   # Other configurations, but we have a compiler.  Assume the user knows
3029   # what he's doing.
3030   yes:*:*:yes)
3031     echo "configure: warning: trying to bootstrap a cross compiler" 1>&2
3032     ;;
3033
3034   # No compiler: if they passed --enable-bootstrap explicitly, fail
3035   no:*:*:yes)
3036     { echo "configure: error: cannot bootstrap without a compiler" 1>&2; exit 1; } ;;
3037
3038   # Fail if wrong command line
3039   *)
3040     { echo "configure: error: invalid option for --enable-bootstrap" 1>&2; exit 1; }
3041     ;;
3042 esac
3043
3044 # Adjust the toplevel makefile according to whether bootstrap was selected.
3045 case "$enable_bootstrap" in
3046   yes)
3047     bootstrap_suffix=bootstrap ;;
3048   no)
3049     bootstrap_suffix=no-bootstrap ;;
3050 esac
3051
3052 for module in ${build_configdirs} ; do
3053   if test -z "${no_recursion}" \
3054      && test -f ${build_subdir}/${module}/Makefile; then
3055     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
3056     rm -f ${build_subdir}/${module}/Makefile
3057   fi
3058   extrasub="$extrasub
3059 /^@if build-$module\$/d
3060 /^@endif build-$module\$/d
3061 /^@if build-$module-$bootstrap_suffix\$/d
3062 /^@endif build-$module-$bootstrap_suffix\$/d"
3063 done
3064 for module in ${configdirs} ; do
3065   if test -z "${no_recursion}"; then
3066     for file in stage*-${module}/Makefile ${module}/Makefile; do
3067       if test -f ${file}; then
3068         echo 1>&2 "*** removing ${file} to force reconfigure"
3069         rm -f ${file}
3070       fi
3071     done
3072   fi
3073   extrasub="$extrasub
3074 /^@if $module\$/d
3075 /^@endif $module\$/d
3076 /^@if $module-$bootstrap_suffix\$/d
3077 /^@endif $module-$bootstrap_suffix\$/d"
3078 done
3079 for module in ${target_configdirs} ; do
3080   if test -z "${no_recursion}" \
3081      && test -f ${target_subdir}/${module}/Makefile; then
3082     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
3083     rm -f ${target_subdir}/${module}/Makefile
3084   fi
3085   extrasub="$extrasub
3086 /^@if target-$module\$/d
3087 /^@endif target-$module\$/d
3088 /^@if target-$module-$bootstrap_suffix\$/d
3089 /^@endif target-$module-$bootstrap_suffix\$/d"
3090 done
3091
3092 extrasub="$extrasub
3093 /^@if /,/^@endif /d"
3094
3095 # Create the serialization dependencies.  This uses a temporary file.
3096
3097 # Check whether --enable-serial-configure or --disable-serial-configure was given.
3098 if test "${enable_serial_configure+set}" = set; then
3099   enableval="$enable_serial_configure"
3100   :
3101 fi
3102
3103
3104 case ${enable_serial_configure} in
3105   yes)
3106     enable_serial_build_configure=yes
3107     enable_serial_host_configure=yes
3108     enable_serial_target_configure=yes
3109     ;;
3110 esac
3111
3112 # These force 'configure's to be done one at a time, to avoid problems
3113 # with contention over a shared config.cache.
3114 rm -f serdep.tmp
3115 echo '# serdep.tmp' > serdep.tmp
3116 olditem=
3117 test "x${enable_serial_build_configure}" = xyes &&
3118 for item in ${build_configdirs} ; do
3119   case ${olditem} in
3120     "") ;;
3121     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
3122   esac
3123   olditem=${item}
3124 done
3125 olditem=
3126 test "x${enable_serial_host_configure}" = xyes &&
3127 for item in ${configdirs} ; do
3128   case ${olditem} in
3129     "") ;;
3130     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
3131   esac
3132   olditem=${item}
3133 done
3134 olditem=
3135 test "x${enable_serial_target_configure}" = xyes &&
3136 for item in ${target_configdirs} ; do
3137   case ${olditem} in
3138     "") ;;
3139     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
3140   esac
3141   olditem=${item}
3142 done
3143 serialization_dependencies=serdep.tmp
3144
3145
3146 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
3147 # target and nonopt.  These are the ones we might not want to pass
3148 # down to subconfigures.  Also strip program-prefix, program-suffix,
3149 # and program-transform-name, so that we can pass down a consistent
3150 # program-transform-name.  If autoconf has put single quotes around
3151 # any of these arguments (because they contain shell metacharacters)
3152 # then this will fail; in practice this only happens for
3153 # --program-transform-name, so be sure to override --program-transform-name
3154 # at the end of the argument list.
3155 # These will be expanded by make, so quote '$'.
3156 cat <<\EOF_SED > conftestsed
3157 s/ --no[^ ]*/ /g
3158 s/ --c[a-z-]*[= ][^ ]*//g
3159 s/ --sr[a-z-]*[= ][^ ]*//g
3160 s/ --ho[a-z-]*[= ][^ ]*//g
3161 s/ --bu[a-z-]*[= ][^ ]*//g
3162 s/ --t[a-z-]*[= ][^ ]*//g
3163 s/ --program-[pst][a-z-]*[= ][^ ]*//g
3164 s/ -cache-file[= ][^ ]*//g
3165 s/ -srcdir[= ][^ ]*//g
3166 s/ -host[= ][^ ]*//g
3167 s/ -build[= ][^ ]*//g
3168 s/ -target[= ][^ ]*//g
3169 s/ -program-prefix[= ][^ ]*//g
3170 s/ -program-suffix[= ][^ ]*//g
3171 s/ -program-transform-name[= ][^ ]*//g
3172 s/ [^' -][^ ]* / /
3173 s/^ *//;s/ *$//
3174 s,\$,$$,g
3175 EOF_SED
3176 sed -f conftestsed <<EOF_SED > conftestsed.out
3177  ${ac_configure_args}
3178 EOF_SED
3179 baseargs=`cat conftestsed.out`
3180 rm -f conftestsed conftestsed.out
3181
3182 # Add in --program-transform-name, after --program-prefix and
3183 # --program-suffix have been applied to it.  Autoconf has already
3184 # doubled dollar signs and backslashes in program_transform_name; we want
3185 # the backslashes un-doubled, and then the entire thing wrapped in single
3186 # quotes, because this will be expanded first by make and then by the shell.
3187 # Also, because we want to override the logic in subdir configure scripts to
3188 # choose program_transform_name, replace any s,x,x, with s,y,y,.
3189 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
3190 ${program_transform_name}
3191 EOF_SED
3192 gcc_transform_name=`cat conftestsed.out`
3193 rm -f conftestsed.out
3194 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
3195
3196 # For the build-side libraries, we just need to pretend we're native,
3197 # and not use the same cache file.  Multilibs are neither needed nor
3198 # desired.
3199 build_configargs="--cache-file=../config.cache --build=${build_alias} --host=${build_alias} --target=${target_alias} ${baseargs}"
3200
3201 # For host modules, accept cache file option, or specification as blank.
3202 case "${cache_file}" in
3203 "") # empty
3204   cache_file_option="" ;;
3205 /* | [A-Za-z]:[\\/]* ) # absolute path
3206   cache_file_option="--cache-file=${cache_file}" ;;
3207 *) # relative path
3208   cache_file_option="--cache-file=../${cache_file}" ;;
3209 esac
3210
3211 # Host dirs don't like to share a cache file either, horribly enough.
3212 # This seems to be due to autoconf 2.5x stupidity.
3213 host_configargs="--cache-file=./config.cache --build=${build_alias} --host=${host_alias} --target=${target_alias} ${extra_host_args} ${baseargs}"
3214
3215 target_configargs=${baseargs}
3216
3217 # Passing a --with-cross-host argument lets the target libraries know
3218 # whether they are being built with a cross-compiler or being built
3219 # native.  However, it would be better to use other mechanisms to make the
3220 # sorts of decisions they want to make on this basis.  Please consider
3221 # this option to be deprecated.  FIXME.
3222 if test x${is_cross_compiler} = xyes ; then
3223   target_configargs="--with-cross-host=${host_alias} ${target_configargs}"
3224 fi
3225
3226 # Default to --enable-multilib.
3227 if test x${enable_multilib} = x ; then
3228   target_configargs="--enable-multilib ${target_configargs}"
3229 fi
3230
3231 # Pass --with-newlib if appropriate.  Note that target_configdirs has
3232 # changed from the earlier setting of with_newlib.
3233 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
3234   target_configargs="--with-newlib ${target_configargs}"
3235 fi
3236
3237 # Different target subdirs use different values of certain variables
3238 # (notably CXX).  Worse, multilibs use *lots* of different values.
3239 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
3240 # it doesn't automatically accept command-line overrides of them.
3241 # This means it's not safe for target subdirs to share a cache file,
3242 # which is disgusting, but there you have it.  Hopefully this can be
3243 # fixed in future.  It's still worthwhile to use a cache file for each
3244 # directory.  I think.
3245
3246 # Pass the appropriate --build, --host, --target and --cache-file arguments.
3247 # We need to pass --target, as newer autoconf's requires consistency
3248 # for target_alias and gcc doesn't manage it consistently.
3249 target_configargs="--cache-file=./config.cache --build=${build_alias} --host=${target_alias} --target=${target_alias} ${target_configargs}"
3250
3251 FLAGS_FOR_TARGET=
3252 case " $target_configdirs " in
3253  *" newlib "*)
3254   case " $target_configargs " in
3255   *" --with-newlib "*)
3256    case "$target" in
3257    *-cygwin*)
3258      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' ;;
3259    esac
3260
3261    # If we're not building GCC, don't discard standard headers.
3262    if test -d ${srcdir}/gcc; then
3263      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
3264
3265      if test "${build}" != "${host}"; then
3266        # On Canadian crosses, CC_FOR_TARGET will have already been set
3267        # by `configure', so we won't have an opportunity to add -Bgcc/
3268        # to it.  This is right: we don't want to search that directory
3269        # for binaries, but we want the header files in there, so add
3270        # them explicitly.
3271        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
3272
3273        # Someone might think of using the pre-installed headers on
3274        # Canadian crosses, in case the installed compiler is not fully
3275        # compatible with the compiler being built.  In this case, it
3276        # would be better to flag an error than risking having
3277        # incompatible object files being constructed.  We can't
3278        # guarantee that an error will be flagged, but let's hope the
3279        # compiler will do it, when presented with incompatible header
3280        # files.
3281      fi
3282    fi
3283
3284    case "${target}-${is_cross_compiler}" in
3285    i[3456789]86-*-linux*-no)
3286       # Here host == target, so we don't need to build gcc,
3287       # so we don't want to discard standard headers.
3288       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
3289       ;;
3290    *)
3291       # If we're building newlib, use its generic headers last, but search
3292       # for any libc-related directories first (so make it the last -B
3293       # switch).
3294       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
3295       ;;
3296    esac
3297    ;;
3298   esac
3299   ;;
3300 esac
3301
3302 # Allow the user to override the flags for
3303 # our build compiler if desired.
3304 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
3305
3306 # On Canadian crosses, we'll be searching the right directories for
3307 # the previously-installed cross compiler, so don't bother to add
3308 # flags for directories within the install tree of the compiler
3309 # being built; programs in there won't even run.
3310 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
3311   # Search for pre-installed headers if nothing else fits.
3312   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
3313 fi
3314
3315 if test "x${use_gnu_ld}" = x &&
3316    echo " ${configdirs} " | grep " ld " > /dev/null ; then
3317   # Arrange for us to find uninstalled linker scripts.
3318   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
3319 fi
3320
3321 # Makefile fragments.
3322 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
3323 do
3324   eval fragval=\$$frag
3325   if test $fragval != /dev/null; then
3326     eval $frag=${srcdir}/$fragval
3327   fi
3328 done
3329
3330
3331
3332
3333
3334 # Miscellanea: directories, flags, etc.
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344 # Build module lists & subconfigure args.
3345
3346
3347
3348 # Host module lists & subconfigure args.
3349
3350
3351
3352 # Target module lists & subconfigure args.
3353
3354
3355
3356 # Build tools.
3357
3358
3359
3360 # Generate default definitions for YACC, M4, LEX and other programs that run
3361 # on the build machine.  These are used if the Makefile can't locate these
3362 # programs in objdir.
3363 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
3364
3365 for ac_prog in 'bison -y' byacc yacc
3366 do
3367 # Extract the first word of "$ac_prog", so it can be a program name with args.
3368 set dummy $ac_prog; ac_word=$2
3369 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3370 echo "configure:3371: checking for $ac_word" >&5
3371 if eval "test \"`echo '$''{'ac_cv_prog_YACC'+set}'`\" = set"; then
3372   echo $ac_n "(cached) $ac_c" 1>&6
3373 else
3374   if test -n "$YACC"; then
3375   ac_cv_prog_YACC="$YACC" # Let the user override the test.
3376 else
3377   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3378   ac_dummy="$PATH"
3379   for ac_dir in $ac_dummy; do
3380     test -z "$ac_dir" && ac_dir=.
3381     if test -f $ac_dir/$ac_word; then
3382       ac_cv_prog_YACC="$ac_prog"
3383       break
3384     fi
3385   done
3386   IFS="$ac_save_ifs"
3387 fi
3388 fi
3389 YACC="$ac_cv_prog_YACC"
3390 if test -n "$YACC"; then
3391   echo "$ac_t""$YACC" 1>&6
3392 else
3393   echo "$ac_t""no" 1>&6
3394 fi
3395
3396 test -n "$YACC" && break
3397 done
3398 test -n "$YACC" || YACC="$MISSING bison -y"
3399
3400 case " $build_configdirs " in
3401   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
3402   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
3403 esac
3404
3405 for ac_prog in bison
3406 do
3407 # Extract the first word of "$ac_prog", so it can be a program name with args.
3408 set dummy $ac_prog; ac_word=$2
3409 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3410 echo "configure:3411: checking for $ac_word" >&5
3411 if eval "test \"`echo '$''{'ac_cv_prog_BISON'+set}'`\" = set"; then
3412   echo $ac_n "(cached) $ac_c" 1>&6
3413 else
3414   if test -n "$BISON"; then
3415   ac_cv_prog_BISON="$BISON" # Let the user override the test.
3416 else
3417   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3418   ac_dummy="$PATH"
3419   for ac_dir in $ac_dummy; do
3420     test -z "$ac_dir" && ac_dir=.
3421     if test -f $ac_dir/$ac_word; then
3422       ac_cv_prog_BISON="$ac_prog"
3423       break
3424     fi
3425   done
3426   IFS="$ac_save_ifs"
3427 fi
3428 fi
3429 BISON="$ac_cv_prog_BISON"
3430 if test -n "$BISON"; then
3431   echo "$ac_t""$BISON" 1>&6
3432 else
3433   echo "$ac_t""no" 1>&6
3434 fi
3435
3436 test -n "$BISON" && break
3437 done
3438 test -n "$BISON" || BISON="$MISSING bison"
3439
3440 case " $build_configdirs " in
3441   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
3442 esac
3443
3444 for ac_prog in gm4 gnum4 m4
3445 do
3446 # Extract the first word of "$ac_prog", so it can be a program name with args.
3447 set dummy $ac_prog; ac_word=$2
3448 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3449 echo "configure:3450: checking for $ac_word" >&5
3450 if eval "test \"`echo '$''{'ac_cv_prog_M4'+set}'`\" = set"; then
3451   echo $ac_n "(cached) $ac_c" 1>&6
3452 else
3453   if test -n "$M4"; then
3454   ac_cv_prog_M4="$M4" # Let the user override the test.
3455 else
3456   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3457   ac_dummy="$PATH"
3458   for ac_dir in $ac_dummy; do
3459     test -z "$ac_dir" && ac_dir=.
3460     if test -f $ac_dir/$ac_word; then
3461       ac_cv_prog_M4="$ac_prog"
3462       break
3463     fi
3464   done
3465   IFS="$ac_save_ifs"
3466 fi
3467 fi
3468 M4="$ac_cv_prog_M4"
3469 if test -n "$M4"; then
3470   echo "$ac_t""$M4" 1>&6
3471 else
3472   echo "$ac_t""no" 1>&6
3473 fi
3474
3475 test -n "$M4" && break
3476 done
3477 test -n "$M4" || M4="$MISSING m4"
3478
3479 case " $build_configdirs " in
3480   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
3481 esac
3482
3483 for ac_prog in flex lex
3484 do
3485 # Extract the first word of "$ac_prog", so it can be a program name with args.
3486 set dummy $ac_prog; ac_word=$2
3487 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3488 echo "configure:3489: checking for $ac_word" >&5
3489 if eval "test \"`echo '$''{'ac_cv_prog_LEX'+set}'`\" = set"; then
3490   echo $ac_n "(cached) $ac_c" 1>&6
3491 else
3492   if test -n "$LEX"; then
3493   ac_cv_prog_LEX="$LEX" # Let the user override the test.
3494 else
3495   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3496   ac_dummy="$PATH"
3497   for ac_dir in $ac_dummy; do
3498     test -z "$ac_dir" && ac_dir=.
3499     if test -f $ac_dir/$ac_word; then
3500       ac_cv_prog_LEX="$ac_prog"
3501       break
3502     fi
3503   done
3504   IFS="$ac_save_ifs"
3505 fi
3506 fi
3507 LEX="$ac_cv_prog_LEX"
3508 if test -n "$LEX"; then
3509   echo "$ac_t""$LEX" 1>&6
3510 else
3511   echo "$ac_t""no" 1>&6
3512 fi
3513
3514 test -n "$LEX" && break
3515 done
3516 test -n "$LEX" || LEX="$MISSING flex"
3517
3518 case " $build_configdirs " in
3519   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
3520   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
3521 esac
3522
3523 for ac_prog in flex
3524 do
3525 # Extract the first word of "$ac_prog", so it can be a program name with args.
3526 set dummy $ac_prog; ac_word=$2
3527 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3528 echo "configure:3529: checking for $ac_word" >&5
3529 if eval "test \"`echo '$''{'ac_cv_prog_FLEX'+set}'`\" = set"; then
3530   echo $ac_n "(cached) $ac_c" 1>&6
3531 else
3532   if test -n "$FLEX"; then
3533   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
3534 else
3535   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3536   ac_dummy="$PATH"
3537   for ac_dir in $ac_dummy; do
3538     test -z "$ac_dir" && ac_dir=.
3539     if test -f $ac_dir/$ac_word; then
3540       ac_cv_prog_FLEX="$ac_prog"
3541       break
3542     fi
3543   done
3544   IFS="$ac_save_ifs"
3545 fi
3546 fi
3547 FLEX="$ac_cv_prog_FLEX"
3548 if test -n "$FLEX"; then
3549   echo "$ac_t""$FLEX" 1>&6
3550 else
3551   echo "$ac_t""no" 1>&6
3552 fi
3553
3554 test -n "$FLEX" && break
3555 done
3556 test -n "$FLEX" || FLEX="$MISSING flex"
3557
3558 case " $build_configdirs " in
3559   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
3560 esac
3561
3562 for ac_prog in makeinfo
3563 do
3564 # Extract the first word of "$ac_prog", so it can be a program name with args.
3565 set dummy $ac_prog; ac_word=$2
3566 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3567 echo "configure:3568: checking for $ac_word" >&5
3568 if eval "test \"`echo '$''{'ac_cv_prog_MAKEINFO'+set}'`\" = set"; then
3569   echo $ac_n "(cached) $ac_c" 1>&6
3570 else
3571   if test -n "$MAKEINFO"; then
3572   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
3573 else
3574   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3575   ac_dummy="$PATH"
3576   for ac_dir in $ac_dummy; do
3577     test -z "$ac_dir" && ac_dir=.
3578     if test -f $ac_dir/$ac_word; then
3579       ac_cv_prog_MAKEINFO="$ac_prog"
3580       break
3581     fi
3582   done
3583   IFS="$ac_save_ifs"
3584 fi
3585 fi
3586 MAKEINFO="$ac_cv_prog_MAKEINFO"
3587 if test -n "$MAKEINFO"; then
3588   echo "$ac_t""$MAKEINFO" 1>&6
3589 else
3590   echo "$ac_t""no" 1>&6
3591 fi
3592
3593 test -n "$MAKEINFO" && break
3594 done
3595 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
3596
3597 case " $build_configdirs " in
3598   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
3599   *)
3600
3601     # For an installed makeinfo, we require it to be from texinfo 4.2 or
3602     # higher, else we use the "missing" dummy.
3603     if ${MAKEINFO} --version \
3604        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[2-9]|[5-9])' >/dev/null 2>&1; then
3605       :
3606     else
3607       MAKEINFO="$MISSING makeinfo"
3608     fi
3609     ;;
3610
3611 esac
3612
3613 # FIXME: expect and dejagnu may become build tools?
3614
3615 for ac_prog in expect
3616 do
3617 # Extract the first word of "$ac_prog", so it can be a program name with args.
3618 set dummy $ac_prog; ac_word=$2
3619 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3620 echo "configure:3621: checking for $ac_word" >&5
3621 if eval "test \"`echo '$''{'ac_cv_prog_EXPECT'+set}'`\" = set"; then
3622   echo $ac_n "(cached) $ac_c" 1>&6
3623 else
3624   if test -n "$EXPECT"; then
3625   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
3626 else
3627   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3628   ac_dummy="$PATH"
3629   for ac_dir in $ac_dummy; do
3630     test -z "$ac_dir" && ac_dir=.
3631     if test -f $ac_dir/$ac_word; then
3632       ac_cv_prog_EXPECT="$ac_prog"
3633       break
3634     fi
3635   done
3636   IFS="$ac_save_ifs"
3637 fi
3638 fi
3639 EXPECT="$ac_cv_prog_EXPECT"
3640 if test -n "$EXPECT"; then
3641   echo "$ac_t""$EXPECT" 1>&6
3642 else
3643   echo "$ac_t""no" 1>&6
3644 fi
3645
3646 test -n "$EXPECT" && break
3647 done
3648 test -n "$EXPECT" || EXPECT="expect"
3649
3650 case " $configdirs " in
3651   *" expect "*)
3652     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
3653     ;;
3654 esac
3655
3656 for ac_prog in runtest
3657 do
3658 # Extract the first word of "$ac_prog", so it can be a program name with args.
3659 set dummy $ac_prog; ac_word=$2
3660 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3661 echo "configure:3662: checking for $ac_word" >&5
3662 if eval "test \"`echo '$''{'ac_cv_prog_RUNTEST'+set}'`\" = set"; then
3663   echo $ac_n "(cached) $ac_c" 1>&6
3664 else
3665   if test -n "$RUNTEST"; then
3666   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
3667 else
3668   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3669   ac_dummy="$PATH"
3670   for ac_dir in $ac_dummy; do
3671     test -z "$ac_dir" && ac_dir=.
3672     if test -f $ac_dir/$ac_word; then
3673       ac_cv_prog_RUNTEST="$ac_prog"
3674       break
3675     fi
3676   done
3677   IFS="$ac_save_ifs"
3678 fi
3679 fi
3680 RUNTEST="$ac_cv_prog_RUNTEST"
3681 if test -n "$RUNTEST"; then
3682   echo "$ac_t""$RUNTEST" 1>&6
3683 else
3684   echo "$ac_t""no" 1>&6
3685 fi
3686
3687 test -n "$RUNTEST" && break
3688 done
3689 test -n "$RUNTEST" || RUNTEST="runtest"
3690
3691 case " $configdirs " in
3692   *" dejagnu "*)
3693     test $host = $build && RUNTEST='$$r/$(HOST_SUBDIR)/dejagnu/runtest'
3694     ;;
3695 esac
3696
3697
3698 # Host tools.
3699 ncn_tool_prefix=
3700 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
3701 ncn_target_tool_prefix=
3702 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
3703
3704  for ncn_progname in ar; do
3705   if test -n "$ncn_tool_prefix"; then
3706     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
3707 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
3708 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3709 echo "configure:3710: checking for $ac_word" >&5
3710 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
3711   echo $ac_n "(cached) $ac_c" 1>&6
3712 else
3713   if test -n "$AR"; then
3714   ac_cv_prog_AR="$AR" # Let the user override the test.
3715 else
3716   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3717   ac_dummy="$PATH"
3718   for ac_dir in $ac_dummy; do
3719     test -z "$ac_dir" && ac_dir=.
3720     if test -f $ac_dir/$ac_word; then
3721       ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
3722       break
3723     fi
3724   done
3725   IFS="$ac_save_ifs"
3726 fi
3727 fi
3728 AR="$ac_cv_prog_AR"
3729 if test -n "$AR"; then
3730   echo "$ac_t""$AR" 1>&6
3731 else
3732   echo "$ac_t""no" 1>&6
3733 fi
3734
3735   fi
3736   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
3737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
3738 set dummy ${ncn_progname}; ac_word=$2
3739 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3740 echo "configure:3741: checking for $ac_word" >&5
3741 if eval "test \"`echo '$''{'ac_cv_prog_AR'+set}'`\" = set"; then
3742   echo $ac_n "(cached) $ac_c" 1>&6
3743 else
3744   if test -n "$AR"; then
3745   ac_cv_prog_AR="$AR" # Let the user override the test.
3746 else
3747   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3748   ac_dummy="$PATH"
3749   for ac_dir in $ac_dummy; do
3750     test -z "$ac_dir" && ac_dir=.
3751     if test -f $ac_dir/$ac_word; then
3752       ac_cv_prog_AR="${ncn_progname}"
3753       break
3754     fi
3755   done
3756   IFS="$ac_save_ifs"
3757 fi
3758 fi
3759 AR="$ac_cv_prog_AR"
3760 if test -n "$AR"; then
3761   echo "$ac_t""$AR" 1>&6
3762 else
3763   echo "$ac_t""no" 1>&6
3764 fi
3765
3766   fi
3767   test -n "$ac_cv_prog_AR" && break
3768 done
3769
3770 if test -z "$ac_cv_prog_AR" ; then
3771   set dummy ar
3772   if test $build = $host ; then
3773     AR="$2"
3774   else
3775     AR="${ncn_tool_prefix}$2"
3776   fi
3777 fi
3778
3779  for ncn_progname in as; do
3780   if test -n "$ncn_tool_prefix"; then
3781     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
3782 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
3783 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3784 echo "configure:3785: checking for $ac_word" >&5
3785 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
3786   echo $ac_n "(cached) $ac_c" 1>&6
3787 else
3788   if test -n "$AS"; then
3789   ac_cv_prog_AS="$AS" # Let the user override the test.
3790 else
3791   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3792   ac_dummy="$PATH"
3793   for ac_dir in $ac_dummy; do
3794     test -z "$ac_dir" && ac_dir=.
3795     if test -f $ac_dir/$ac_word; then
3796       ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
3797       break
3798     fi
3799   done
3800   IFS="$ac_save_ifs"
3801 fi
3802 fi
3803 AS="$ac_cv_prog_AS"
3804 if test -n "$AS"; then
3805   echo "$ac_t""$AS" 1>&6
3806 else
3807   echo "$ac_t""no" 1>&6
3808 fi
3809
3810   fi
3811   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
3812     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
3813 set dummy ${ncn_progname}; ac_word=$2
3814 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3815 echo "configure:3816: checking for $ac_word" >&5
3816 if eval "test \"`echo '$''{'ac_cv_prog_AS'+set}'`\" = set"; then
3817   echo $ac_n "(cached) $ac_c" 1>&6
3818 else
3819   if test -n "$AS"; then
3820   ac_cv_prog_AS="$AS" # Let the user override the test.
3821 else
3822   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3823   ac_dummy="$PATH"
3824   for ac_dir in $ac_dummy; do
3825     test -z "$ac_dir" && ac_dir=.
3826     if test -f $ac_dir/$ac_word; then
3827       ac_cv_prog_AS="${ncn_progname}"
3828       break
3829     fi
3830   done
3831   IFS="$ac_save_ifs"
3832 fi
3833 fi
3834 AS="$ac_cv_prog_AS"
3835 if test -n "$AS"; then
3836   echo "$ac_t""$AS" 1>&6
3837 else
3838   echo "$ac_t""no" 1>&6
3839 fi
3840
3841   fi
3842   test -n "$ac_cv_prog_AS" && break
3843 done
3844
3845 if test -z "$ac_cv_prog_AS" ; then
3846   set dummy as
3847   if test $build = $host ; then
3848     AS="$2"
3849   else
3850     AS="${ncn_tool_prefix}$2"
3851   fi
3852 fi
3853
3854  for ncn_progname in dlltool; do
3855   if test -n "$ncn_tool_prefix"; then
3856     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
3857 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
3858 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3859 echo "configure:3860: checking for $ac_word" >&5
3860 if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
3861   echo $ac_n "(cached) $ac_c" 1>&6
3862 else
3863   if test -n "$DLLTOOL"; then
3864   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
3865 else
3866   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3867   ac_dummy="$PATH"
3868   for ac_dir in $ac_dummy; do
3869     test -z "$ac_dir" && ac_dir=.
3870     if test -f $ac_dir/$ac_word; then
3871       ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
3872       break
3873     fi
3874   done
3875   IFS="$ac_save_ifs"
3876 fi
3877 fi
3878 DLLTOOL="$ac_cv_prog_DLLTOOL"
3879 if test -n "$DLLTOOL"; then
3880   echo "$ac_t""$DLLTOOL" 1>&6
3881 else
3882   echo "$ac_t""no" 1>&6
3883 fi
3884
3885   fi
3886   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
3887     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
3888 set dummy ${ncn_progname}; ac_word=$2
3889 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3890 echo "configure:3891: checking for $ac_word" >&5
3891 if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL'+set}'`\" = set"; then
3892   echo $ac_n "(cached) $ac_c" 1>&6
3893 else
3894   if test -n "$DLLTOOL"; then
3895   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
3896 else
3897   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3898   ac_dummy="$PATH"
3899   for ac_dir in $ac_dummy; do
3900     test -z "$ac_dir" && ac_dir=.
3901     if test -f $ac_dir/$ac_word; then
3902       ac_cv_prog_DLLTOOL="${ncn_progname}"
3903       break
3904     fi
3905   done
3906   IFS="$ac_save_ifs"
3907 fi
3908 fi
3909 DLLTOOL="$ac_cv_prog_DLLTOOL"
3910 if test -n "$DLLTOOL"; then
3911   echo "$ac_t""$DLLTOOL" 1>&6
3912 else
3913   echo "$ac_t""no" 1>&6
3914 fi
3915
3916   fi
3917   test -n "$ac_cv_prog_DLLTOOL" && break
3918 done
3919
3920 if test -z "$ac_cv_prog_DLLTOOL" ; then
3921   set dummy dlltool
3922   if test $build = $host ; then
3923     DLLTOOL="$2"
3924   else
3925     DLLTOOL="${ncn_tool_prefix}$2"
3926   fi
3927 fi
3928
3929  for ncn_progname in ld; do
3930   if test -n "$ncn_tool_prefix"; then
3931     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
3932 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
3933 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3934 echo "configure:3935: checking for $ac_word" >&5
3935 if eval "test \"`echo '$''{'ac_cv_prog_LD'+set}'`\" = set"; then
3936   echo $ac_n "(cached) $ac_c" 1>&6
3937 else
3938   if test -n "$LD"; then
3939   ac_cv_prog_LD="$LD" # Let the user override the test.
3940 else
3941   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3942   ac_dummy="$PATH"
3943   for ac_dir in $ac_dummy; do
3944     test -z "$ac_dir" && ac_dir=.
3945     if test -f $ac_dir/$ac_word; then
3946       ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
3947       break
3948     fi
3949   done
3950   IFS="$ac_save_ifs"
3951 fi
3952 fi
3953 LD="$ac_cv_prog_LD"
3954 if test -n "$LD"; then
3955   echo "$ac_t""$LD" 1>&6
3956 else
3957   echo "$ac_t""no" 1>&6
3958 fi
3959
3960   fi
3961   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
3962     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
3963 set dummy ${ncn_progname}; ac_word=$2
3964 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
3965 echo "configure:3966: checking for $ac_word" >&5
3966 if eval "test \"`echo '$''{'ac_cv_prog_LD'+set}'`\" = set"; then
3967   echo $ac_n "(cached) $ac_c" 1>&6
3968 else
3969   if test -n "$LD"; then
3970   ac_cv_prog_LD="$LD" # Let the user override the test.
3971 else
3972   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3973   ac_dummy="$PATH"
3974   for ac_dir in $ac_dummy; do
3975     test -z "$ac_dir" && ac_dir=.
3976     if test -f $ac_dir/$ac_word; then
3977       ac_cv_prog_LD="${ncn_progname}"
3978       break
3979     fi
3980   done
3981   IFS="$ac_save_ifs"
3982 fi
3983 fi
3984 LD="$ac_cv_prog_LD"
3985 if test -n "$LD"; then
3986   echo "$ac_t""$LD" 1>&6
3987 else
3988   echo "$ac_t""no" 1>&6
3989 fi
3990
3991   fi
3992   test -n "$ac_cv_prog_LD" && break
3993 done
3994
3995 if test -z "$ac_cv_prog_LD" ; then
3996   set dummy ld
3997   if test $build = $host ; then
3998     LD="$2"
3999   else
4000     LD="${ncn_tool_prefix}$2"
4001   fi
4002 fi
4003
4004  for ncn_progname in lipo; do
4005   if test -n "$ncn_tool_prefix"; then
4006     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4007 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4008 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4009 echo "configure:4010: checking for $ac_word" >&5
4010 if eval "test \"`echo '$''{'ac_cv_prog_LIPO'+set}'`\" = set"; then
4011   echo $ac_n "(cached) $ac_c" 1>&6
4012 else
4013   if test -n "$LIPO"; then
4014   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
4015 else
4016   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4017   ac_dummy="$PATH"
4018   for ac_dir in $ac_dummy; do
4019     test -z "$ac_dir" && ac_dir=.
4020     if test -f $ac_dir/$ac_word; then
4021       ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
4022       break
4023     fi
4024   done
4025   IFS="$ac_save_ifs"
4026 fi
4027 fi
4028 LIPO="$ac_cv_prog_LIPO"
4029 if test -n "$LIPO"; then
4030   echo "$ac_t""$LIPO" 1>&6
4031 else
4032   echo "$ac_t""no" 1>&6
4033 fi
4034
4035   fi
4036   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
4037     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4038 set dummy ${ncn_progname}; ac_word=$2
4039 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4040 echo "configure:4041: checking for $ac_word" >&5
4041 if eval "test \"`echo '$''{'ac_cv_prog_LIPO'+set}'`\" = set"; then
4042   echo $ac_n "(cached) $ac_c" 1>&6
4043 else
4044   if test -n "$LIPO"; then
4045   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
4046 else
4047   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4048   ac_dummy="$PATH"
4049   for ac_dir in $ac_dummy; do
4050     test -z "$ac_dir" && ac_dir=.
4051     if test -f $ac_dir/$ac_word; then
4052       ac_cv_prog_LIPO="${ncn_progname}"
4053       break
4054     fi
4055   done
4056   IFS="$ac_save_ifs"
4057 fi
4058 fi
4059 LIPO="$ac_cv_prog_LIPO"
4060 if test -n "$LIPO"; then
4061   echo "$ac_t""$LIPO" 1>&6
4062 else
4063   echo "$ac_t""no" 1>&6
4064 fi
4065
4066   fi
4067   test -n "$ac_cv_prog_LIPO" && break
4068 done
4069
4070 if test -z "$ac_cv_prog_LIPO" ; then
4071   set dummy lipo
4072   if test $build = $host ; then
4073     LIPO="$2"
4074   else
4075     LIPO="${ncn_tool_prefix}$2"
4076   fi
4077 fi
4078
4079  for ncn_progname in nm; do
4080   if test -n "$ncn_tool_prefix"; then
4081     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4082 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4083 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4084 echo "configure:4085: checking for $ac_word" >&5
4085 if eval "test \"`echo '$''{'ac_cv_prog_NM'+set}'`\" = set"; then
4086   echo $ac_n "(cached) $ac_c" 1>&6
4087 else
4088   if test -n "$NM"; then
4089   ac_cv_prog_NM="$NM" # Let the user override the test.
4090 else
4091   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4092   ac_dummy="$PATH"
4093   for ac_dir in $ac_dummy; do
4094     test -z "$ac_dir" && ac_dir=.
4095     if test -f $ac_dir/$ac_word; then
4096       ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
4097       break
4098     fi
4099   done
4100   IFS="$ac_save_ifs"
4101 fi
4102 fi
4103 NM="$ac_cv_prog_NM"
4104 if test -n "$NM"; then
4105   echo "$ac_t""$NM" 1>&6
4106 else
4107   echo "$ac_t""no" 1>&6
4108 fi
4109
4110   fi
4111   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
4112     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4113 set dummy ${ncn_progname}; ac_word=$2
4114 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4115 echo "configure:4116: checking for $ac_word" >&5
4116 if eval "test \"`echo '$''{'ac_cv_prog_NM'+set}'`\" = set"; then
4117   echo $ac_n "(cached) $ac_c" 1>&6
4118 else
4119   if test -n "$NM"; then
4120   ac_cv_prog_NM="$NM" # Let the user override the test.
4121 else
4122   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4123   ac_dummy="$PATH"
4124   for ac_dir in $ac_dummy; do
4125     test -z "$ac_dir" && ac_dir=.
4126     if test -f $ac_dir/$ac_word; then
4127       ac_cv_prog_NM="${ncn_progname}"
4128       break
4129     fi
4130   done
4131   IFS="$ac_save_ifs"
4132 fi
4133 fi
4134 NM="$ac_cv_prog_NM"
4135 if test -n "$NM"; then
4136   echo "$ac_t""$NM" 1>&6
4137 else
4138   echo "$ac_t""no" 1>&6
4139 fi
4140
4141   fi
4142   test -n "$ac_cv_prog_NM" && break
4143 done
4144
4145 if test -z "$ac_cv_prog_NM" ; then
4146   set dummy nm
4147   if test $build = $host ; then
4148     NM="$2"
4149   else
4150     NM="${ncn_tool_prefix}$2"
4151   fi
4152 fi
4153
4154  for ncn_progname in ranlib; do
4155   if test -n "$ncn_tool_prefix"; then
4156     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4157 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4158 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4159 echo "configure:4160: checking for $ac_word" >&5
4160 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
4161   echo $ac_n "(cached) $ac_c" 1>&6
4162 else
4163   if test -n "$RANLIB"; then
4164   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4165 else
4166   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4167   ac_dummy="$PATH"
4168   for ac_dir in $ac_dummy; do
4169     test -z "$ac_dir" && ac_dir=.
4170     if test -f $ac_dir/$ac_word; then
4171       ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
4172       break
4173     fi
4174   done
4175   IFS="$ac_save_ifs"
4176 fi
4177 fi
4178 RANLIB="$ac_cv_prog_RANLIB"
4179 if test -n "$RANLIB"; then
4180   echo "$ac_t""$RANLIB" 1>&6
4181 else
4182   echo "$ac_t""no" 1>&6
4183 fi
4184
4185   fi
4186   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
4187     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4188 set dummy ${ncn_progname}; ac_word=$2
4189 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4190 echo "configure:4191: checking for $ac_word" >&5
4191 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB'+set}'`\" = set"; then
4192   echo $ac_n "(cached) $ac_c" 1>&6
4193 else
4194   if test -n "$RANLIB"; then
4195   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
4196 else
4197   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4198   ac_dummy="$PATH"
4199   for ac_dir in $ac_dummy; do
4200     test -z "$ac_dir" && ac_dir=.
4201     if test -f $ac_dir/$ac_word; then
4202       ac_cv_prog_RANLIB="${ncn_progname}"
4203       break
4204     fi
4205   done
4206   IFS="$ac_save_ifs"
4207 fi
4208 fi
4209 RANLIB="$ac_cv_prog_RANLIB"
4210 if test -n "$RANLIB"; then
4211   echo "$ac_t""$RANLIB" 1>&6
4212 else
4213   echo "$ac_t""no" 1>&6
4214 fi
4215
4216   fi
4217   test -n "$ac_cv_prog_RANLIB" && break
4218 done
4219
4220 if test -z "$ac_cv_prog_RANLIB" ; then
4221   RANLIB=":"
4222 fi
4223
4224  for ncn_progname in strip; do
4225   if test -n "$ncn_tool_prefix"; then
4226     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4227 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4228 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4229 echo "configure:4230: checking for $ac_word" >&5
4230 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
4231   echo $ac_n "(cached) $ac_c" 1>&6
4232 else
4233   if test -n "$STRIP"; then
4234   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4235 else
4236   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4237   ac_dummy="$PATH"
4238   for ac_dir in $ac_dummy; do
4239     test -z "$ac_dir" && ac_dir=.
4240     if test -f $ac_dir/$ac_word; then
4241       ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
4242       break
4243     fi
4244   done
4245   IFS="$ac_save_ifs"
4246 fi
4247 fi
4248 STRIP="$ac_cv_prog_STRIP"
4249 if test -n "$STRIP"; then
4250   echo "$ac_t""$STRIP" 1>&6
4251 else
4252   echo "$ac_t""no" 1>&6
4253 fi
4254
4255   fi
4256   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
4257     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4258 set dummy ${ncn_progname}; ac_word=$2
4259 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4260 echo "configure:4261: checking for $ac_word" >&5
4261 if eval "test \"`echo '$''{'ac_cv_prog_STRIP'+set}'`\" = set"; then
4262   echo $ac_n "(cached) $ac_c" 1>&6
4263 else
4264   if test -n "$STRIP"; then
4265   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
4266 else
4267   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4268   ac_dummy="$PATH"
4269   for ac_dir in $ac_dummy; do
4270     test -z "$ac_dir" && ac_dir=.
4271     if test -f $ac_dir/$ac_word; then
4272       ac_cv_prog_STRIP="${ncn_progname}"
4273       break
4274     fi
4275   done
4276   IFS="$ac_save_ifs"
4277 fi
4278 fi
4279 STRIP="$ac_cv_prog_STRIP"
4280 if test -n "$STRIP"; then
4281   echo "$ac_t""$STRIP" 1>&6
4282 else
4283   echo "$ac_t""no" 1>&6
4284 fi
4285
4286   fi
4287   test -n "$ac_cv_prog_STRIP" && break
4288 done
4289
4290 if test -z "$ac_cv_prog_STRIP" ; then
4291   STRIP=":"
4292 fi
4293
4294  for ncn_progname in windres; do
4295   if test -n "$ncn_tool_prefix"; then
4296     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4297 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4298 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4299 echo "configure:4300: checking for $ac_word" >&5
4300 if eval "test \"`echo '$''{'ac_cv_prog_WINDRES'+set}'`\" = set"; then
4301   echo $ac_n "(cached) $ac_c" 1>&6
4302 else
4303   if test -n "$WINDRES"; then
4304   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
4305 else
4306   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4307   ac_dummy="$PATH"
4308   for ac_dir in $ac_dummy; do
4309     test -z "$ac_dir" && ac_dir=.
4310     if test -f $ac_dir/$ac_word; then
4311       ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
4312       break
4313     fi
4314   done
4315   IFS="$ac_save_ifs"
4316 fi
4317 fi
4318 WINDRES="$ac_cv_prog_WINDRES"
4319 if test -n "$WINDRES"; then
4320   echo "$ac_t""$WINDRES" 1>&6
4321 else
4322   echo "$ac_t""no" 1>&6
4323 fi
4324
4325   fi
4326   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
4327     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4328 set dummy ${ncn_progname}; ac_word=$2
4329 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4330 echo "configure:4331: checking for $ac_word" >&5
4331 if eval "test \"`echo '$''{'ac_cv_prog_WINDRES'+set}'`\" = set"; then
4332   echo $ac_n "(cached) $ac_c" 1>&6
4333 else
4334   if test -n "$WINDRES"; then
4335   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
4336 else
4337   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4338   ac_dummy="$PATH"
4339   for ac_dir in $ac_dummy; do
4340     test -z "$ac_dir" && ac_dir=.
4341     if test -f $ac_dir/$ac_word; then
4342       ac_cv_prog_WINDRES="${ncn_progname}"
4343       break
4344     fi
4345   done
4346   IFS="$ac_save_ifs"
4347 fi
4348 fi
4349 WINDRES="$ac_cv_prog_WINDRES"
4350 if test -n "$WINDRES"; then
4351   echo "$ac_t""$WINDRES" 1>&6
4352 else
4353   echo "$ac_t""no" 1>&6
4354 fi
4355
4356   fi
4357   test -n "$ac_cv_prog_WINDRES" && break
4358 done
4359
4360 if test -z "$ac_cv_prog_WINDRES" ; then
4361   set dummy windres
4362   if test $build = $host ; then
4363     WINDRES="$2"
4364   else
4365     WINDRES="${ncn_tool_prefix}$2"
4366   fi
4367 fi
4368
4369  for ncn_progname in objcopy; do
4370   if test -n "$ncn_tool_prefix"; then
4371     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4372 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4373 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4374 echo "configure:4375: checking for $ac_word" >&5
4375 if eval "test \"`echo '$''{'ac_cv_prog_OBJCOPY'+set}'`\" = set"; then
4376   echo $ac_n "(cached) $ac_c" 1>&6
4377 else
4378   if test -n "$OBJCOPY"; then
4379   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
4380 else
4381   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4382   ac_dummy="$PATH"
4383   for ac_dir in $ac_dummy; do
4384     test -z "$ac_dir" && ac_dir=.
4385     if test -f $ac_dir/$ac_word; then
4386       ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
4387       break
4388     fi
4389   done
4390   IFS="$ac_save_ifs"
4391 fi
4392 fi
4393 OBJCOPY="$ac_cv_prog_OBJCOPY"
4394 if test -n "$OBJCOPY"; then
4395   echo "$ac_t""$OBJCOPY" 1>&6
4396 else
4397   echo "$ac_t""no" 1>&6
4398 fi
4399
4400   fi
4401   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
4402     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4403 set dummy ${ncn_progname}; ac_word=$2
4404 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4405 echo "configure:4406: checking for $ac_word" >&5
4406 if eval "test \"`echo '$''{'ac_cv_prog_OBJCOPY'+set}'`\" = set"; then
4407   echo $ac_n "(cached) $ac_c" 1>&6
4408 else
4409   if test -n "$OBJCOPY"; then
4410   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
4411 else
4412   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4413   ac_dummy="$PATH"
4414   for ac_dir in $ac_dummy; do
4415     test -z "$ac_dir" && ac_dir=.
4416     if test -f $ac_dir/$ac_word; then
4417       ac_cv_prog_OBJCOPY="${ncn_progname}"
4418       break
4419     fi
4420   done
4421   IFS="$ac_save_ifs"
4422 fi
4423 fi
4424 OBJCOPY="$ac_cv_prog_OBJCOPY"
4425 if test -n "$OBJCOPY"; then
4426   echo "$ac_t""$OBJCOPY" 1>&6
4427 else
4428   echo "$ac_t""no" 1>&6
4429 fi
4430
4431   fi
4432   test -n "$ac_cv_prog_OBJCOPY" && break
4433 done
4434
4435 if test -z "$ac_cv_prog_OBJCOPY" ; then
4436   set dummy objcopy
4437   if test $build = $host ; then
4438     OBJCOPY="$2"
4439   else
4440     OBJCOPY="${ncn_tool_prefix}$2"
4441   fi
4442 fi
4443
4444  for ncn_progname in objdump; do
4445   if test -n "$ncn_tool_prefix"; then
4446     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
4447 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
4448 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4449 echo "configure:4450: checking for $ac_word" >&5
4450 if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
4451   echo $ac_n "(cached) $ac_c" 1>&6
4452 else
4453   if test -n "$OBJDUMP"; then
4454   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
4455 else
4456   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4457   ac_dummy="$PATH"
4458   for ac_dir in $ac_dummy; do
4459     test -z "$ac_dir" && ac_dir=.
4460     if test -f $ac_dir/$ac_word; then
4461       ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
4462       break
4463     fi
4464   done
4465   IFS="$ac_save_ifs"
4466 fi
4467 fi
4468 OBJDUMP="$ac_cv_prog_OBJDUMP"
4469 if test -n "$OBJDUMP"; then
4470   echo "$ac_t""$OBJDUMP" 1>&6
4471 else
4472   echo "$ac_t""no" 1>&6
4473 fi
4474
4475   fi
4476   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
4477     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4478 set dummy ${ncn_progname}; ac_word=$2
4479 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4480 echo "configure:4481: checking for $ac_word" >&5
4481 if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP'+set}'`\" = set"; then
4482   echo $ac_n "(cached) $ac_c" 1>&6
4483 else
4484   if test -n "$OBJDUMP"; then
4485   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
4486 else
4487   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4488   ac_dummy="$PATH"
4489   for ac_dir in $ac_dummy; do
4490     test -z "$ac_dir" && ac_dir=.
4491     if test -f $ac_dir/$ac_word; then
4492       ac_cv_prog_OBJDUMP="${ncn_progname}"
4493       break
4494     fi
4495   done
4496   IFS="$ac_save_ifs"
4497 fi
4498 fi
4499 OBJDUMP="$ac_cv_prog_OBJDUMP"
4500 if test -n "$OBJDUMP"; then
4501   echo "$ac_t""$OBJDUMP" 1>&6
4502 else
4503   echo "$ac_t""no" 1>&6
4504 fi
4505
4506   fi
4507   test -n "$ac_cv_prog_OBJDUMP" && break
4508 done
4509
4510 if test -z "$ac_cv_prog_OBJDUMP" ; then
4511   set dummy objdump
4512   if test $build = $host ; then
4513     OBJDUMP="$2"
4514   else
4515     OBJDUMP="${ncn_tool_prefix}$2"
4516   fi
4517 fi
4518
4519
4520
4521
4522
4523
4524
4525 # Target tools.
4526 # Check whether --with-build-time-tools or --without-build-time-tools was given.
4527 if test "${with_build_time_tools+set}" = set; then
4528   withval="$with_build_time_tools"
4529   case x"$withval" in
4530      x/*) ;;
4531      *)
4532        with_build_time_tools=
4533        echo "configure: warning: argument to --with-build-time-tools must be an absolute path" 1>&2
4534        ;;
4535    esac
4536 else
4537   with_build_time_tools=
4538 fi
4539
4540
4541  if test -n "$with_build_time_tools"; then
4542   for ncn_progname in cc gcc; do
4543     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4544 echo "configure:4545: checking for ${ncn_progname} in $with_build_time_tools" >&5
4545     if test -x $with_build_time_tools/${ncn_progname}; then
4546       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4547       echo "$ac_t""yes" 1>&6
4548       break
4549     else
4550       echo "$ac_t""no" 1>&6
4551     fi
4552   done
4553 fi
4554
4555 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
4556   for ncn_progname in cc gcc; do
4557     if test -n "$ncn_target_tool_prefix"; then
4558       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4559 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4560 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4561 echo "configure:4562: checking for $ac_word" >&5
4562 if eval "test \"`echo '$''{'ac_cv_prog_CC_FOR_TARGET'+set}'`\" = set"; then
4563   echo $ac_n "(cached) $ac_c" 1>&6
4564 else
4565   if test -n "$CC_FOR_TARGET"; then
4566   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
4567 else
4568   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4569   ac_dummy="$PATH"
4570   for ac_dir in $ac_dummy; do
4571     test -z "$ac_dir" && ac_dir=.
4572     if test -f $ac_dir/$ac_word; then
4573       ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4574       break
4575     fi
4576   done
4577   IFS="$ac_save_ifs"
4578 fi
4579 fi
4580 CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
4581 if test -n "$CC_FOR_TARGET"; then
4582   echo "$ac_t""$CC_FOR_TARGET" 1>&6
4583 else
4584   echo "$ac_t""no" 1>&6
4585 fi
4586
4587     fi
4588     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
4589       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4590 set dummy ${ncn_progname}; ac_word=$2
4591 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4592 echo "configure:4593: checking for $ac_word" >&5
4593 if eval "test \"`echo '$''{'ac_cv_prog_CC_FOR_TARGET'+set}'`\" = set"; then
4594   echo $ac_n "(cached) $ac_c" 1>&6
4595 else
4596   if test -n "$CC_FOR_TARGET"; then
4597   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
4598 else
4599   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4600   ac_dummy="$PATH"
4601   for ac_dir in $ac_dummy; do
4602     test -z "$ac_dir" && ac_dir=.
4603     if test -f $ac_dir/$ac_word; then
4604       ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
4605       break
4606     fi
4607   done
4608   IFS="$ac_save_ifs"
4609 fi
4610 fi
4611 CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
4612 if test -n "$CC_FOR_TARGET"; then
4613   echo "$ac_t""$CC_FOR_TARGET" 1>&6
4614 else
4615   echo "$ac_t""no" 1>&6
4616 fi
4617
4618     fi
4619     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
4620   done
4621 fi
4622
4623 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
4624   set dummy cc gcc
4625   if test $build = $target ; then
4626     CC_FOR_TARGET="$2"
4627   else
4628     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
4629   fi
4630 fi
4631
4632  if test -n "$with_build_time_tools"; then
4633   for ncn_progname in c++ g++ cxx gxx; do
4634     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4635 echo "configure:4636: checking for ${ncn_progname} in $with_build_time_tools" >&5
4636     if test -x $with_build_time_tools/${ncn_progname}; then
4637       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4638       echo "$ac_t""yes" 1>&6
4639       break
4640     else
4641       echo "$ac_t""no" 1>&6
4642     fi
4643   done
4644 fi
4645
4646 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
4647   for ncn_progname in c++ g++ cxx gxx; do
4648     if test -n "$ncn_target_tool_prefix"; then
4649       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4650 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4651 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4652 echo "configure:4653: checking for $ac_word" >&5
4653 if eval "test \"`echo '$''{'ac_cv_prog_CXX_FOR_TARGET'+set}'`\" = set"; then
4654   echo $ac_n "(cached) $ac_c" 1>&6
4655 else
4656   if test -n "$CXX_FOR_TARGET"; then
4657   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
4658 else
4659   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4660   ac_dummy="$PATH"
4661   for ac_dir in $ac_dummy; do
4662     test -z "$ac_dir" && ac_dir=.
4663     if test -f $ac_dir/$ac_word; then
4664       ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4665       break
4666     fi
4667   done
4668   IFS="$ac_save_ifs"
4669 fi
4670 fi
4671 CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
4672 if test -n "$CXX_FOR_TARGET"; then
4673   echo "$ac_t""$CXX_FOR_TARGET" 1>&6
4674 else
4675   echo "$ac_t""no" 1>&6
4676 fi
4677
4678     fi
4679     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
4680       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4681 set dummy ${ncn_progname}; ac_word=$2
4682 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4683 echo "configure:4684: checking for $ac_word" >&5
4684 if eval "test \"`echo '$''{'ac_cv_prog_CXX_FOR_TARGET'+set}'`\" = set"; then
4685   echo $ac_n "(cached) $ac_c" 1>&6
4686 else
4687   if test -n "$CXX_FOR_TARGET"; then
4688   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
4689 else
4690   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4691   ac_dummy="$PATH"
4692   for ac_dir in $ac_dummy; do
4693     test -z "$ac_dir" && ac_dir=.
4694     if test -f $ac_dir/$ac_word; then
4695       ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
4696       break
4697     fi
4698   done
4699   IFS="$ac_save_ifs"
4700 fi
4701 fi
4702 CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
4703 if test -n "$CXX_FOR_TARGET"; then
4704   echo "$ac_t""$CXX_FOR_TARGET" 1>&6
4705 else
4706   echo "$ac_t""no" 1>&6
4707 fi
4708
4709     fi
4710     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
4711   done
4712 fi
4713
4714 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
4715   set dummy c++ g++ cxx gxx
4716   if test $build = $target ; then
4717     CXX_FOR_TARGET="$2"
4718   else
4719     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
4720   fi
4721 fi
4722
4723  if test -n "$with_build_time_tools"; then
4724   for ncn_progname in gcc; do
4725     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4726 echo "configure:4727: checking for ${ncn_progname} in $with_build_time_tools" >&5
4727     if test -x $with_build_time_tools/${ncn_progname}; then
4728       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4729       echo "$ac_t""yes" 1>&6
4730       break
4731     else
4732       echo "$ac_t""no" 1>&6
4733     fi
4734   done
4735 fi
4736
4737 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
4738   for ncn_progname in gcc; do
4739     if test -n "$ncn_target_tool_prefix"; then
4740       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4741 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4742 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4743 echo "configure:4744: checking for $ac_word" >&5
4744 if eval "test \"`echo '$''{'ac_cv_prog_GCC_FOR_TARGET'+set}'`\" = set"; then
4745   echo $ac_n "(cached) $ac_c" 1>&6
4746 else
4747   if test -n "$GCC_FOR_TARGET"; then
4748   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
4749 else
4750   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4751   ac_dummy="$PATH"
4752   for ac_dir in $ac_dummy; do
4753     test -z "$ac_dir" && ac_dir=.
4754     if test -f $ac_dir/$ac_word; then
4755       ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4756       break
4757     fi
4758   done
4759   IFS="$ac_save_ifs"
4760 fi
4761 fi
4762 GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
4763 if test -n "$GCC_FOR_TARGET"; then
4764   echo "$ac_t""$GCC_FOR_TARGET" 1>&6
4765 else
4766   echo "$ac_t""no" 1>&6
4767 fi
4768
4769     fi
4770     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
4771       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4772 set dummy ${ncn_progname}; ac_word=$2
4773 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4774 echo "configure:4775: checking for $ac_word" >&5
4775 if eval "test \"`echo '$''{'ac_cv_prog_GCC_FOR_TARGET'+set}'`\" = set"; then
4776   echo $ac_n "(cached) $ac_c" 1>&6
4777 else
4778   if test -n "$GCC_FOR_TARGET"; then
4779   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
4780 else
4781   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4782   ac_dummy="$PATH"
4783   for ac_dir in $ac_dummy; do
4784     test -z "$ac_dir" && ac_dir=.
4785     if test -f $ac_dir/$ac_word; then
4786       ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
4787       break
4788     fi
4789   done
4790   IFS="$ac_save_ifs"
4791 fi
4792 fi
4793 GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
4794 if test -n "$GCC_FOR_TARGET"; then
4795   echo "$ac_t""$GCC_FOR_TARGET" 1>&6
4796 else
4797   echo "$ac_t""no" 1>&6
4798 fi
4799
4800     fi
4801     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
4802   done
4803 fi
4804
4805 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
4806   GCC_FOR_TARGET="${CC_FOR_TARGET}"
4807 fi
4808
4809  if test -n "$with_build_time_tools"; then
4810   for ncn_progname in gcj; do
4811     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4812 echo "configure:4813: checking for ${ncn_progname} in $with_build_time_tools" >&5
4813     if test -x $with_build_time_tools/${ncn_progname}; then
4814       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4815       echo "$ac_t""yes" 1>&6
4816       break
4817     else
4818       echo "$ac_t""no" 1>&6
4819     fi
4820   done
4821 fi
4822
4823 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
4824   for ncn_progname in gcj; do
4825     if test -n "$ncn_target_tool_prefix"; then
4826       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4827 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4828 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4829 echo "configure:4830: checking for $ac_word" >&5
4830 if eval "test \"`echo '$''{'ac_cv_prog_GCJ_FOR_TARGET'+set}'`\" = set"; then
4831   echo $ac_n "(cached) $ac_c" 1>&6
4832 else
4833   if test -n "$GCJ_FOR_TARGET"; then
4834   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
4835 else
4836   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4837   ac_dummy="$PATH"
4838   for ac_dir in $ac_dummy; do
4839     test -z "$ac_dir" && ac_dir=.
4840     if test -f $ac_dir/$ac_word; then
4841       ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4842       break
4843     fi
4844   done
4845   IFS="$ac_save_ifs"
4846 fi
4847 fi
4848 GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
4849 if test -n "$GCJ_FOR_TARGET"; then
4850   echo "$ac_t""$GCJ_FOR_TARGET" 1>&6
4851 else
4852   echo "$ac_t""no" 1>&6
4853 fi
4854
4855     fi
4856     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
4857       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4858 set dummy ${ncn_progname}; ac_word=$2
4859 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4860 echo "configure:4861: checking for $ac_word" >&5
4861 if eval "test \"`echo '$''{'ac_cv_prog_GCJ_FOR_TARGET'+set}'`\" = set"; then
4862   echo $ac_n "(cached) $ac_c" 1>&6
4863 else
4864   if test -n "$GCJ_FOR_TARGET"; then
4865   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
4866 else
4867   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4868   ac_dummy="$PATH"
4869   for ac_dir in $ac_dummy; do
4870     test -z "$ac_dir" && ac_dir=.
4871     if test -f $ac_dir/$ac_word; then
4872       ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
4873       break
4874     fi
4875   done
4876   IFS="$ac_save_ifs"
4877 fi
4878 fi
4879 GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
4880 if test -n "$GCJ_FOR_TARGET"; then
4881   echo "$ac_t""$GCJ_FOR_TARGET" 1>&6
4882 else
4883   echo "$ac_t""no" 1>&6
4884 fi
4885
4886     fi
4887     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
4888   done
4889 fi
4890
4891 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
4892   set dummy gcj
4893   if test $build = $target ; then
4894     GCJ_FOR_TARGET="$2"
4895   else
4896     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
4897   fi
4898 fi
4899
4900  if test -n "$with_build_time_tools"; then
4901   for ncn_progname in gfortran; do
4902     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
4903 echo "configure:4904: checking for ${ncn_progname} in $with_build_time_tools" >&5
4904     if test -x $with_build_time_tools/${ncn_progname}; then
4905       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
4906       echo "$ac_t""yes" 1>&6
4907       break
4908     else
4909       echo "$ac_t""no" 1>&6
4910     fi
4911   done
4912 fi
4913
4914 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
4915   for ncn_progname in gfortran; do
4916     if test -n "$ncn_target_tool_prefix"; then
4917       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
4918 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
4919 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4920 echo "configure:4921: checking for $ac_word" >&5
4921 if eval "test \"`echo '$''{'ac_cv_prog_GFORTRAN_FOR_TARGET'+set}'`\" = set"; then
4922   echo $ac_n "(cached) $ac_c" 1>&6
4923 else
4924   if test -n "$GFORTRAN_FOR_TARGET"; then
4925   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
4926 else
4927   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4928   ac_dummy="$PATH"
4929   for ac_dir in $ac_dummy; do
4930     test -z "$ac_dir" && ac_dir=.
4931     if test -f $ac_dir/$ac_word; then
4932       ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
4933       break
4934     fi
4935   done
4936   IFS="$ac_save_ifs"
4937 fi
4938 fi
4939 GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
4940 if test -n "$GFORTRAN_FOR_TARGET"; then
4941   echo "$ac_t""$GFORTRAN_FOR_TARGET" 1>&6
4942 else
4943   echo "$ac_t""no" 1>&6
4944 fi
4945
4946     fi
4947     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
4948       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
4949 set dummy ${ncn_progname}; ac_word=$2
4950 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
4951 echo "configure:4952: checking for $ac_word" >&5
4952 if eval "test \"`echo '$''{'ac_cv_prog_GFORTRAN_FOR_TARGET'+set}'`\" = set"; then
4953   echo $ac_n "(cached) $ac_c" 1>&6
4954 else
4955   if test -n "$GFORTRAN_FOR_TARGET"; then
4956   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
4957 else
4958   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
4959   ac_dummy="$PATH"
4960   for ac_dir in $ac_dummy; do
4961     test -z "$ac_dir" && ac_dir=.
4962     if test -f $ac_dir/$ac_word; then
4963       ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
4964       break
4965     fi
4966   done
4967   IFS="$ac_save_ifs"
4968 fi
4969 fi
4970 GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
4971 if test -n "$GFORTRAN_FOR_TARGET"; then
4972   echo "$ac_t""$GFORTRAN_FOR_TARGET" 1>&6
4973 else
4974   echo "$ac_t""no" 1>&6
4975 fi
4976
4977     fi
4978     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
4979   done
4980 fi
4981
4982 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
4983   set dummy gfortran
4984   if test $build = $target ; then
4985     GFORTRAN_FOR_TARGET="$2"
4986   else
4987     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
4988   fi
4989 fi
4990
4991
4992
4993 # The user is always right.
4994 if test "${PATH_SEPARATOR+set}" != set; then
4995   echo "#! /bin/sh" >conf$$.sh
4996   echo  "exit 0"   >>conf$$.sh
4997   chmod +x conf$$.sh
4998   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
4999     PATH_SEPARATOR=';'
5000   else
5001     PATH_SEPARATOR=:
5002   fi
5003   rm -f conf$$.sh
5004 fi
5005
5006
5007
5008 if test "x$exec_prefix" = xNONE; then
5009         if test "x$prefix" = xNONE; then
5010                 gcc_cv_tool_prefix=$ac_default_prefix
5011         else
5012                 gcc_cv_tool_prefix=$prefix
5013         fi
5014 else
5015         gcc_cv_tool_prefix=$exec_prefix
5016 fi
5017
5018 # If there is no compiler in the tree, use the PATH only.  In any
5019 # case, if there is no compiler in the tree nobody should use
5020 # AS_FOR_TARGET and LD_FOR_TARGET.
5021 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5022     gcc_version=`cat $srcdir/gcc/BASE-VER`
5023     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5024     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5025     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5026     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5027     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5028     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5029 else
5030     gcc_cv_tool_dirs=
5031 fi
5032
5033 if test x$build = x$target && test -n "$md_exec_prefix"; then
5034         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5035 fi
5036
5037
5038
5039 cat > conftest.c << \EOF
5040 #ifdef __GNUC__
5041   gcc_yay;
5042 #endif
5043 EOF
5044 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
5045   have_gcc_for_target=yes
5046 else
5047   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
5048   have_gcc_for_target=no
5049 fi
5050 rm conftest.c
5051
5052
5053
5054
5055 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
5056   if test -n "$with_build_time_tools"; then
5057     echo $ac_n "checking for ar in $with_build_time_tools""... $ac_c" 1>&6
5058 echo "configure:5059: checking for ar in $with_build_time_tools" >&5
5059     if test -x $with_build_time_tools/ar; then
5060       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
5061       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
5062       echo "$ac_t""$ac_cv_path_AR_FOR_TARGET" 1>&6
5063     else
5064       echo "$ac_t""no" 1>&6
5065     fi
5066   elif test $build != $host && test $have_gcc_for_target = yes; then
5067     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
5068     test $AR_FOR_TARGET=ar && AR_FOR_TARGET=
5069     ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
5070   fi
5071 fi
5072 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
5073   # Extract the first word of "ar", so it can be a program name with args.
5074 set dummy ar; ac_word=$2
5075 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5076 echo "configure:5077: checking for $ac_word" >&5
5077 if eval "test \"`echo '$''{'ac_cv_path_AR_FOR_TARGET'+set}'`\" = set"; then
5078   echo $ac_n "(cached) $ac_c" 1>&6
5079 else
5080   case "$AR_FOR_TARGET" in
5081   /*)
5082   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
5083   ;;
5084   ?:/*)
5085   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a dos path.
5086   ;;
5087   *)
5088   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5089   ac_dummy="$gcc_cv_tool_dirs"
5090   for ac_dir in $ac_dummy; do
5091     test -z "$ac_dir" && ac_dir=.
5092     if test -f $ac_dir/$ac_word; then
5093       ac_cv_path_AR_FOR_TARGET="$ac_dir/$ac_word"
5094       break
5095     fi
5096   done
5097   IFS="$ac_save_ifs"
5098   ;;
5099 esac
5100 fi
5101 AR_FOR_TARGET="$ac_cv_path_AR_FOR_TARGET"
5102 if test -n "$AR_FOR_TARGET"; then
5103   echo "$ac_t""$AR_FOR_TARGET" 1>&6
5104 else
5105   echo "$ac_t""no" 1>&6
5106 fi
5107
5108 fi
5109 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
5110    if test -n "$with_build_time_tools"; then
5111   for ncn_progname in ar; do
5112     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5113 echo "configure:5114: checking for ${ncn_progname} in $with_build_time_tools" >&5
5114     if test -x $with_build_time_tools/${ncn_progname}; then
5115       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5116       echo "$ac_t""yes" 1>&6
5117       break
5118     else
5119       echo "$ac_t""no" 1>&6
5120     fi
5121   done
5122 fi
5123
5124 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
5125   for ncn_progname in ar; do
5126     if test -n "$ncn_target_tool_prefix"; then
5127       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5128 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5129 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5130 echo "configure:5131: checking for $ac_word" >&5
5131 if eval "test \"`echo '$''{'ac_cv_prog_AR_FOR_TARGET'+set}'`\" = set"; then
5132   echo $ac_n "(cached) $ac_c" 1>&6
5133 else
5134   if test -n "$AR_FOR_TARGET"; then
5135   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
5136 else
5137   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5138   ac_dummy="$PATH"
5139   for ac_dir in $ac_dummy; do
5140     test -z "$ac_dir" && ac_dir=.
5141     if test -f $ac_dir/$ac_word; then
5142       ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5143       break
5144     fi
5145   done
5146   IFS="$ac_save_ifs"
5147 fi
5148 fi
5149 AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
5150 if test -n "$AR_FOR_TARGET"; then
5151   echo "$ac_t""$AR_FOR_TARGET" 1>&6
5152 else
5153   echo "$ac_t""no" 1>&6
5154 fi
5155
5156     fi
5157     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
5158       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5159 set dummy ${ncn_progname}; ac_word=$2
5160 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5161 echo "configure:5162: checking for $ac_word" >&5
5162 if eval "test \"`echo '$''{'ac_cv_prog_AR_FOR_TARGET'+set}'`\" = set"; then
5163   echo $ac_n "(cached) $ac_c" 1>&6
5164 else
5165   if test -n "$AR_FOR_TARGET"; then
5166   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
5167 else
5168   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5169   ac_dummy="$PATH"
5170   for ac_dir in $ac_dummy; do
5171     test -z "$ac_dir" && ac_dir=.
5172     if test -f $ac_dir/$ac_word; then
5173       ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
5174       break
5175     fi
5176   done
5177   IFS="$ac_save_ifs"
5178 fi
5179 fi
5180 AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
5181 if test -n "$AR_FOR_TARGET"; then
5182   echo "$ac_t""$AR_FOR_TARGET" 1>&6
5183 else
5184   echo "$ac_t""no" 1>&6
5185 fi
5186
5187     fi
5188     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
5189   done
5190 fi
5191
5192 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
5193   set dummy ar
5194   if test $build = $target ; then
5195     AR_FOR_TARGET="$2"
5196   else
5197     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
5198   fi
5199 fi
5200
5201 else
5202   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
5203 fi
5204
5205
5206
5207
5208 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
5209   if test -n "$with_build_time_tools"; then
5210     echo $ac_n "checking for as in $with_build_time_tools""... $ac_c" 1>&6
5211 echo "configure:5212: checking for as in $with_build_time_tools" >&5
5212     if test -x $with_build_time_tools/as; then
5213       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
5214       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
5215       echo "$ac_t""$ac_cv_path_AS_FOR_TARGET" 1>&6
5216     else
5217       echo "$ac_t""no" 1>&6
5218     fi
5219   elif test $build != $host && test $have_gcc_for_target = yes; then
5220     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
5221     test $AS_FOR_TARGET=as && AS_FOR_TARGET=
5222     ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
5223   fi
5224 fi
5225 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
5226   # Extract the first word of "as", so it can be a program name with args.
5227 set dummy as; ac_word=$2
5228 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5229 echo "configure:5230: checking for $ac_word" >&5
5230 if eval "test \"`echo '$''{'ac_cv_path_AS_FOR_TARGET'+set}'`\" = set"; then
5231   echo $ac_n "(cached) $ac_c" 1>&6
5232 else
5233   case "$AS_FOR_TARGET" in
5234   /*)
5235   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
5236   ;;
5237   ?:/*)
5238   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a dos path.
5239   ;;
5240   *)
5241   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5242   ac_dummy="$gcc_cv_tool_dirs"
5243   for ac_dir in $ac_dummy; do
5244     test -z "$ac_dir" && ac_dir=.
5245     if test -f $ac_dir/$ac_word; then
5246       ac_cv_path_AS_FOR_TARGET="$ac_dir/$ac_word"
5247       break
5248     fi
5249   done
5250   IFS="$ac_save_ifs"
5251   ;;
5252 esac
5253 fi
5254 AS_FOR_TARGET="$ac_cv_path_AS_FOR_TARGET"
5255 if test -n "$AS_FOR_TARGET"; then
5256   echo "$ac_t""$AS_FOR_TARGET" 1>&6
5257 else
5258   echo "$ac_t""no" 1>&6
5259 fi
5260
5261 fi
5262 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
5263    if test -n "$with_build_time_tools"; then
5264   for ncn_progname in as; do
5265     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5266 echo "configure:5267: checking for ${ncn_progname} in $with_build_time_tools" >&5
5267     if test -x $with_build_time_tools/${ncn_progname}; then
5268       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5269       echo "$ac_t""yes" 1>&6
5270       break
5271     else
5272       echo "$ac_t""no" 1>&6
5273     fi
5274   done
5275 fi
5276
5277 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
5278   for ncn_progname in as; do
5279     if test -n "$ncn_target_tool_prefix"; then
5280       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5281 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5282 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5283 echo "configure:5284: checking for $ac_word" >&5
5284 if eval "test \"`echo '$''{'ac_cv_prog_AS_FOR_TARGET'+set}'`\" = set"; then
5285   echo $ac_n "(cached) $ac_c" 1>&6
5286 else
5287   if test -n "$AS_FOR_TARGET"; then
5288   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
5289 else
5290   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5291   ac_dummy="$PATH"
5292   for ac_dir in $ac_dummy; do
5293     test -z "$ac_dir" && ac_dir=.
5294     if test -f $ac_dir/$ac_word; then
5295       ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5296       break
5297     fi
5298   done
5299   IFS="$ac_save_ifs"
5300 fi
5301 fi
5302 AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
5303 if test -n "$AS_FOR_TARGET"; then
5304   echo "$ac_t""$AS_FOR_TARGET" 1>&6
5305 else
5306   echo "$ac_t""no" 1>&6
5307 fi
5308
5309     fi
5310     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
5311       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5312 set dummy ${ncn_progname}; ac_word=$2
5313 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5314 echo "configure:5315: checking for $ac_word" >&5
5315 if eval "test \"`echo '$''{'ac_cv_prog_AS_FOR_TARGET'+set}'`\" = set"; then
5316   echo $ac_n "(cached) $ac_c" 1>&6
5317 else
5318   if test -n "$AS_FOR_TARGET"; then
5319   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
5320 else
5321   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5322   ac_dummy="$PATH"
5323   for ac_dir in $ac_dummy; do
5324     test -z "$ac_dir" && ac_dir=.
5325     if test -f $ac_dir/$ac_word; then
5326       ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
5327       break
5328     fi
5329   done
5330   IFS="$ac_save_ifs"
5331 fi
5332 fi
5333 AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
5334 if test -n "$AS_FOR_TARGET"; then
5335   echo "$ac_t""$AS_FOR_TARGET" 1>&6
5336 else
5337   echo "$ac_t""no" 1>&6
5338 fi
5339
5340     fi
5341     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
5342   done
5343 fi
5344
5345 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
5346   set dummy as
5347   if test $build = $target ; then
5348     AS_FOR_TARGET="$2"
5349   else
5350     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
5351   fi
5352 fi
5353
5354 else
5355   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
5356 fi
5357
5358
5359
5360
5361 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
5362   if test -n "$with_build_time_tools"; then
5363     echo $ac_n "checking for dlltool in $with_build_time_tools""... $ac_c" 1>&6
5364 echo "configure:5365: checking for dlltool in $with_build_time_tools" >&5
5365     if test -x $with_build_time_tools/dlltool; then
5366       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
5367       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
5368       echo "$ac_t""$ac_cv_path_DLLTOOL_FOR_TARGET" 1>&6
5369     else
5370       echo "$ac_t""no" 1>&6
5371     fi
5372   elif test $build != $host && test $have_gcc_for_target = yes; then
5373     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
5374     test $DLLTOOL_FOR_TARGET=dlltool && DLLTOOL_FOR_TARGET=
5375     ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
5376   fi
5377 fi
5378 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
5379   # Extract the first word of "dlltool", so it can be a program name with args.
5380 set dummy dlltool; ac_word=$2
5381 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5382 echo "configure:5383: checking for $ac_word" >&5
5383 if eval "test \"`echo '$''{'ac_cv_path_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
5384   echo $ac_n "(cached) $ac_c" 1>&6
5385 else
5386   case "$DLLTOOL_FOR_TARGET" in
5387   /*)
5388   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
5389   ;;
5390   ?:/*)
5391   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a dos path.
5392   ;;
5393   *)
5394   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5395   ac_dummy="$gcc_cv_tool_dirs"
5396   for ac_dir in $ac_dummy; do
5397     test -z "$ac_dir" && ac_dir=.
5398     if test -f $ac_dir/$ac_word; then
5399       ac_cv_path_DLLTOOL_FOR_TARGET="$ac_dir/$ac_word"
5400       break
5401     fi
5402   done
5403   IFS="$ac_save_ifs"
5404   ;;
5405 esac
5406 fi
5407 DLLTOOL_FOR_TARGET="$ac_cv_path_DLLTOOL_FOR_TARGET"
5408 if test -n "$DLLTOOL_FOR_TARGET"; then
5409   echo "$ac_t""$DLLTOOL_FOR_TARGET" 1>&6
5410 else
5411   echo "$ac_t""no" 1>&6
5412 fi
5413
5414 fi
5415 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
5416    if test -n "$with_build_time_tools"; then
5417   for ncn_progname in dlltool; do
5418     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5419 echo "configure:5420: checking for ${ncn_progname} in $with_build_time_tools" >&5
5420     if test -x $with_build_time_tools/${ncn_progname}; then
5421       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5422       echo "$ac_t""yes" 1>&6
5423       break
5424     else
5425       echo "$ac_t""no" 1>&6
5426     fi
5427   done
5428 fi
5429
5430 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
5431   for ncn_progname in dlltool; do
5432     if test -n "$ncn_target_tool_prefix"; then
5433       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5434 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5435 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5436 echo "configure:5437: checking for $ac_word" >&5
5437 if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
5438   echo $ac_n "(cached) $ac_c" 1>&6
5439 else
5440   if test -n "$DLLTOOL_FOR_TARGET"; then
5441   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
5442 else
5443   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5444   ac_dummy="$PATH"
5445   for ac_dir in $ac_dummy; do
5446     test -z "$ac_dir" && ac_dir=.
5447     if test -f $ac_dir/$ac_word; then
5448       ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5449       break
5450     fi
5451   done
5452   IFS="$ac_save_ifs"
5453 fi
5454 fi
5455 DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
5456 if test -n "$DLLTOOL_FOR_TARGET"; then
5457   echo "$ac_t""$DLLTOOL_FOR_TARGET" 1>&6
5458 else
5459   echo "$ac_t""no" 1>&6
5460 fi
5461
5462     fi
5463     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
5464       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5465 set dummy ${ncn_progname}; ac_word=$2
5466 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5467 echo "configure:5468: checking for $ac_word" >&5
5468 if eval "test \"`echo '$''{'ac_cv_prog_DLLTOOL_FOR_TARGET'+set}'`\" = set"; then
5469   echo $ac_n "(cached) $ac_c" 1>&6
5470 else
5471   if test -n "$DLLTOOL_FOR_TARGET"; then
5472   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
5473 else
5474   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5475   ac_dummy="$PATH"
5476   for ac_dir in $ac_dummy; do
5477     test -z "$ac_dir" && ac_dir=.
5478     if test -f $ac_dir/$ac_word; then
5479       ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
5480       break
5481     fi
5482   done
5483   IFS="$ac_save_ifs"
5484 fi
5485 fi
5486 DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
5487 if test -n "$DLLTOOL_FOR_TARGET"; then
5488   echo "$ac_t""$DLLTOOL_FOR_TARGET" 1>&6
5489 else
5490   echo "$ac_t""no" 1>&6
5491 fi
5492
5493     fi
5494     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
5495   done
5496 fi
5497
5498 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
5499   set dummy dlltool
5500   if test $build = $target ; then
5501     DLLTOOL_FOR_TARGET="$2"
5502   else
5503     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
5504   fi
5505 fi
5506
5507 else
5508   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
5509 fi
5510
5511
5512
5513
5514 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
5515   if test -n "$with_build_time_tools"; then
5516     echo $ac_n "checking for ld in $with_build_time_tools""... $ac_c" 1>&6
5517 echo "configure:5518: checking for ld in $with_build_time_tools" >&5
5518     if test -x $with_build_time_tools/ld; then
5519       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
5520       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
5521       echo "$ac_t""$ac_cv_path_LD_FOR_TARGET" 1>&6
5522     else
5523       echo "$ac_t""no" 1>&6
5524     fi
5525   elif test $build != $host && test $have_gcc_for_target = yes; then
5526     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
5527     test $LD_FOR_TARGET=ld && LD_FOR_TARGET=
5528     ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
5529   fi
5530 fi
5531 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
5532   # Extract the first word of "ld", so it can be a program name with args.
5533 set dummy ld; ac_word=$2
5534 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5535 echo "configure:5536: checking for $ac_word" >&5
5536 if eval "test \"`echo '$''{'ac_cv_path_LD_FOR_TARGET'+set}'`\" = set"; then
5537   echo $ac_n "(cached) $ac_c" 1>&6
5538 else
5539   case "$LD_FOR_TARGET" in
5540   /*)
5541   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
5542   ;;
5543   ?:/*)
5544   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a dos path.
5545   ;;
5546   *)
5547   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5548   ac_dummy="$gcc_cv_tool_dirs"
5549   for ac_dir in $ac_dummy; do
5550     test -z "$ac_dir" && ac_dir=.
5551     if test -f $ac_dir/$ac_word; then
5552       ac_cv_path_LD_FOR_TARGET="$ac_dir/$ac_word"
5553       break
5554     fi
5555   done
5556   IFS="$ac_save_ifs"
5557   ;;
5558 esac
5559 fi
5560 LD_FOR_TARGET="$ac_cv_path_LD_FOR_TARGET"
5561 if test -n "$LD_FOR_TARGET"; then
5562   echo "$ac_t""$LD_FOR_TARGET" 1>&6
5563 else
5564   echo "$ac_t""no" 1>&6
5565 fi
5566
5567 fi
5568 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
5569    if test -n "$with_build_time_tools"; then
5570   for ncn_progname in ld; do
5571     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5572 echo "configure:5573: checking for ${ncn_progname} in $with_build_time_tools" >&5
5573     if test -x $with_build_time_tools/${ncn_progname}; then
5574       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5575       echo "$ac_t""yes" 1>&6
5576       break
5577     else
5578       echo "$ac_t""no" 1>&6
5579     fi
5580   done
5581 fi
5582
5583 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
5584   for ncn_progname in ld; do
5585     if test -n "$ncn_target_tool_prefix"; then
5586       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5587 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5588 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5589 echo "configure:5590: checking for $ac_word" >&5
5590 if eval "test \"`echo '$''{'ac_cv_prog_LD_FOR_TARGET'+set}'`\" = set"; then
5591   echo $ac_n "(cached) $ac_c" 1>&6
5592 else
5593   if test -n "$LD_FOR_TARGET"; then
5594   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
5595 else
5596   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5597   ac_dummy="$PATH"
5598   for ac_dir in $ac_dummy; do
5599     test -z "$ac_dir" && ac_dir=.
5600     if test -f $ac_dir/$ac_word; then
5601       ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5602       break
5603     fi
5604   done
5605   IFS="$ac_save_ifs"
5606 fi
5607 fi
5608 LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
5609 if test -n "$LD_FOR_TARGET"; then
5610   echo "$ac_t""$LD_FOR_TARGET" 1>&6
5611 else
5612   echo "$ac_t""no" 1>&6
5613 fi
5614
5615     fi
5616     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
5617       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5618 set dummy ${ncn_progname}; ac_word=$2
5619 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5620 echo "configure:5621: checking for $ac_word" >&5
5621 if eval "test \"`echo '$''{'ac_cv_prog_LD_FOR_TARGET'+set}'`\" = set"; then
5622   echo $ac_n "(cached) $ac_c" 1>&6
5623 else
5624   if test -n "$LD_FOR_TARGET"; then
5625   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
5626 else
5627   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5628   ac_dummy="$PATH"
5629   for ac_dir in $ac_dummy; do
5630     test -z "$ac_dir" && ac_dir=.
5631     if test -f $ac_dir/$ac_word; then
5632       ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
5633       break
5634     fi
5635   done
5636   IFS="$ac_save_ifs"
5637 fi
5638 fi
5639 LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
5640 if test -n "$LD_FOR_TARGET"; then
5641   echo "$ac_t""$LD_FOR_TARGET" 1>&6
5642 else
5643   echo "$ac_t""no" 1>&6
5644 fi
5645
5646     fi
5647     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
5648   done
5649 fi
5650
5651 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
5652   set dummy ld
5653   if test $build = $target ; then
5654     LD_FOR_TARGET="$2"
5655   else
5656     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
5657   fi
5658 fi
5659
5660 else
5661   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
5662 fi
5663
5664
5665
5666
5667 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
5668   if test -n "$with_build_time_tools"; then
5669     echo $ac_n "checking for lipo in $with_build_time_tools""... $ac_c" 1>&6
5670 echo "configure:5671: checking for lipo in $with_build_time_tools" >&5
5671     if test -x $with_build_time_tools/lipo; then
5672       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
5673       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
5674       echo "$ac_t""$ac_cv_path_LIPO_FOR_TARGET" 1>&6
5675     else
5676       echo "$ac_t""no" 1>&6
5677     fi
5678   elif test $build != $host && test $have_gcc_for_target = yes; then
5679     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
5680     test $LIPO_FOR_TARGET=lipo && LIPO_FOR_TARGET=
5681     ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
5682   fi
5683 fi
5684 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
5685   # Extract the first word of "lipo", so it can be a program name with args.
5686 set dummy lipo; ac_word=$2
5687 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5688 echo "configure:5689: checking for $ac_word" >&5
5689 if eval "test \"`echo '$''{'ac_cv_path_LIPO_FOR_TARGET'+set}'`\" = set"; then
5690   echo $ac_n "(cached) $ac_c" 1>&6
5691 else
5692   case "$LIPO_FOR_TARGET" in
5693   /*)
5694   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
5695   ;;
5696   ?:/*)
5697   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a dos path.
5698   ;;
5699   *)
5700   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5701   ac_dummy="$gcc_cv_tool_dirs"
5702   for ac_dir in $ac_dummy; do
5703     test -z "$ac_dir" && ac_dir=.
5704     if test -f $ac_dir/$ac_word; then
5705       ac_cv_path_LIPO_FOR_TARGET="$ac_dir/$ac_word"
5706       break
5707     fi
5708   done
5709   IFS="$ac_save_ifs"
5710   ;;
5711 esac
5712 fi
5713 LIPO_FOR_TARGET="$ac_cv_path_LIPO_FOR_TARGET"
5714 if test -n "$LIPO_FOR_TARGET"; then
5715   echo "$ac_t""$LIPO_FOR_TARGET" 1>&6
5716 else
5717   echo "$ac_t""no" 1>&6
5718 fi
5719
5720 fi
5721 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
5722    if test -n "$with_build_time_tools"; then
5723   for ncn_progname in lipo; do
5724     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5725 echo "configure:5726: checking for ${ncn_progname} in $with_build_time_tools" >&5
5726     if test -x $with_build_time_tools/${ncn_progname}; then
5727       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5728       echo "$ac_t""yes" 1>&6
5729       break
5730     else
5731       echo "$ac_t""no" 1>&6
5732     fi
5733   done
5734 fi
5735
5736 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
5737   for ncn_progname in lipo; do
5738     if test -n "$ncn_target_tool_prefix"; then
5739       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5740 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5741 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5742 echo "configure:5743: checking for $ac_word" >&5
5743 if eval "test \"`echo '$''{'ac_cv_prog_LIPO_FOR_TARGET'+set}'`\" = set"; then
5744   echo $ac_n "(cached) $ac_c" 1>&6
5745 else
5746   if test -n "$LIPO_FOR_TARGET"; then
5747   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
5748 else
5749   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5750   ac_dummy="$PATH"
5751   for ac_dir in $ac_dummy; do
5752     test -z "$ac_dir" && ac_dir=.
5753     if test -f $ac_dir/$ac_word; then
5754       ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5755       break
5756     fi
5757   done
5758   IFS="$ac_save_ifs"
5759 fi
5760 fi
5761 LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
5762 if test -n "$LIPO_FOR_TARGET"; then
5763   echo "$ac_t""$LIPO_FOR_TARGET" 1>&6
5764 else
5765   echo "$ac_t""no" 1>&6
5766 fi
5767
5768     fi
5769     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
5770       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5771 set dummy ${ncn_progname}; ac_word=$2
5772 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5773 echo "configure:5774: checking for $ac_word" >&5
5774 if eval "test \"`echo '$''{'ac_cv_prog_LIPO_FOR_TARGET'+set}'`\" = set"; then
5775   echo $ac_n "(cached) $ac_c" 1>&6
5776 else
5777   if test -n "$LIPO_FOR_TARGET"; then
5778   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
5779 else
5780   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5781   ac_dummy="$PATH"
5782   for ac_dir in $ac_dummy; do
5783     test -z "$ac_dir" && ac_dir=.
5784     if test -f $ac_dir/$ac_word; then
5785       ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
5786       break
5787     fi
5788   done
5789   IFS="$ac_save_ifs"
5790 fi
5791 fi
5792 LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
5793 if test -n "$LIPO_FOR_TARGET"; then
5794   echo "$ac_t""$LIPO_FOR_TARGET" 1>&6
5795 else
5796   echo "$ac_t""no" 1>&6
5797 fi
5798
5799     fi
5800     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
5801   done
5802 fi
5803
5804 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
5805   set dummy lipo
5806   if test $build = $target ; then
5807     LIPO_FOR_TARGET="$2"
5808   else
5809     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
5810   fi
5811 fi
5812
5813 else
5814   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
5815 fi
5816
5817
5818
5819
5820 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
5821   if test -n "$with_build_time_tools"; then
5822     echo $ac_n "checking for nm in $with_build_time_tools""... $ac_c" 1>&6
5823 echo "configure:5824: checking for nm in $with_build_time_tools" >&5
5824     if test -x $with_build_time_tools/nm; then
5825       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
5826       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
5827       echo "$ac_t""$ac_cv_path_NM_FOR_TARGET" 1>&6
5828     else
5829       echo "$ac_t""no" 1>&6
5830     fi
5831   elif test $build != $host && test $have_gcc_for_target = yes; then
5832     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
5833     test $NM_FOR_TARGET=nm && NM_FOR_TARGET=
5834     ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
5835   fi
5836 fi
5837 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
5838   # Extract the first word of "nm", so it can be a program name with args.
5839 set dummy nm; ac_word=$2
5840 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5841 echo "configure:5842: checking for $ac_word" >&5
5842 if eval "test \"`echo '$''{'ac_cv_path_NM_FOR_TARGET'+set}'`\" = set"; then
5843   echo $ac_n "(cached) $ac_c" 1>&6
5844 else
5845   case "$NM_FOR_TARGET" in
5846   /*)
5847   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
5848   ;;
5849   ?:/*)
5850   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a dos path.
5851   ;;
5852   *)
5853   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5854   ac_dummy="$gcc_cv_tool_dirs"
5855   for ac_dir in $ac_dummy; do
5856     test -z "$ac_dir" && ac_dir=.
5857     if test -f $ac_dir/$ac_word; then
5858       ac_cv_path_NM_FOR_TARGET="$ac_dir/$ac_word"
5859       break
5860     fi
5861   done
5862   IFS="$ac_save_ifs"
5863   ;;
5864 esac
5865 fi
5866 NM_FOR_TARGET="$ac_cv_path_NM_FOR_TARGET"
5867 if test -n "$NM_FOR_TARGET"; then
5868   echo "$ac_t""$NM_FOR_TARGET" 1>&6
5869 else
5870   echo "$ac_t""no" 1>&6
5871 fi
5872
5873 fi
5874 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
5875    if test -n "$with_build_time_tools"; then
5876   for ncn_progname in nm; do
5877     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
5878 echo "configure:5879: checking for ${ncn_progname} in $with_build_time_tools" >&5
5879     if test -x $with_build_time_tools/${ncn_progname}; then
5880       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
5881       echo "$ac_t""yes" 1>&6
5882       break
5883     else
5884       echo "$ac_t""no" 1>&6
5885     fi
5886   done
5887 fi
5888
5889 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
5890   for ncn_progname in nm; do
5891     if test -n "$ncn_target_tool_prefix"; then
5892       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
5893 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
5894 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5895 echo "configure:5896: checking for $ac_word" >&5
5896 if eval "test \"`echo '$''{'ac_cv_prog_NM_FOR_TARGET'+set}'`\" = set"; then
5897   echo $ac_n "(cached) $ac_c" 1>&6
5898 else
5899   if test -n "$NM_FOR_TARGET"; then
5900   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
5901 else
5902   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5903   ac_dummy="$PATH"
5904   for ac_dir in $ac_dummy; do
5905     test -z "$ac_dir" && ac_dir=.
5906     if test -f $ac_dir/$ac_word; then
5907       ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
5908       break
5909     fi
5910   done
5911   IFS="$ac_save_ifs"
5912 fi
5913 fi
5914 NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
5915 if test -n "$NM_FOR_TARGET"; then
5916   echo "$ac_t""$NM_FOR_TARGET" 1>&6
5917 else
5918   echo "$ac_t""no" 1>&6
5919 fi
5920
5921     fi
5922     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
5923       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
5924 set dummy ${ncn_progname}; ac_word=$2
5925 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5926 echo "configure:5927: checking for $ac_word" >&5
5927 if eval "test \"`echo '$''{'ac_cv_prog_NM_FOR_TARGET'+set}'`\" = set"; then
5928   echo $ac_n "(cached) $ac_c" 1>&6
5929 else
5930   if test -n "$NM_FOR_TARGET"; then
5931   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
5932 else
5933   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
5934   ac_dummy="$PATH"
5935   for ac_dir in $ac_dummy; do
5936     test -z "$ac_dir" && ac_dir=.
5937     if test -f $ac_dir/$ac_word; then
5938       ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
5939       break
5940     fi
5941   done
5942   IFS="$ac_save_ifs"
5943 fi
5944 fi
5945 NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
5946 if test -n "$NM_FOR_TARGET"; then
5947   echo "$ac_t""$NM_FOR_TARGET" 1>&6
5948 else
5949   echo "$ac_t""no" 1>&6
5950 fi
5951
5952     fi
5953     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
5954   done
5955 fi
5956
5957 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
5958   set dummy nm
5959   if test $build = $target ; then
5960     NM_FOR_TARGET="$2"
5961   else
5962     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
5963   fi
5964 fi
5965
5966 else
5967   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
5968 fi
5969
5970
5971
5972
5973 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
5974   if test -n "$with_build_time_tools"; then
5975     echo $ac_n "checking for objdump in $with_build_time_tools""... $ac_c" 1>&6
5976 echo "configure:5977: checking for objdump in $with_build_time_tools" >&5
5977     if test -x $with_build_time_tools/objdump; then
5978       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
5979       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
5980       echo "$ac_t""$ac_cv_path_OBJDUMP_FOR_TARGET" 1>&6
5981     else
5982       echo "$ac_t""no" 1>&6
5983     fi
5984   elif test $build != $host && test $have_gcc_for_target = yes; then
5985     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
5986     test $OBJDUMP_FOR_TARGET=objdump && OBJDUMP_FOR_TARGET=
5987     ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
5988   fi
5989 fi
5990 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
5991   # Extract the first word of "objdump", so it can be a program name with args.
5992 set dummy objdump; ac_word=$2
5993 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
5994 echo "configure:5995: checking for $ac_word" >&5
5995 if eval "test \"`echo '$''{'ac_cv_path_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
5996   echo $ac_n "(cached) $ac_c" 1>&6
5997 else
5998   case "$OBJDUMP_FOR_TARGET" in
5999   /*)
6000   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
6001   ;;
6002   ?:/*)
6003   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a dos path.
6004   ;;
6005   *)
6006   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6007   ac_dummy="$gcc_cv_tool_dirs"
6008   for ac_dir in $ac_dummy; do
6009     test -z "$ac_dir" && ac_dir=.
6010     if test -f $ac_dir/$ac_word; then
6011       ac_cv_path_OBJDUMP_FOR_TARGET="$ac_dir/$ac_word"
6012       break
6013     fi
6014   done
6015   IFS="$ac_save_ifs"
6016   ;;
6017 esac
6018 fi
6019 OBJDUMP_FOR_TARGET="$ac_cv_path_OBJDUMP_FOR_TARGET"
6020 if test -n "$OBJDUMP_FOR_TARGET"; then
6021   echo "$ac_t""$OBJDUMP_FOR_TARGET" 1>&6
6022 else
6023   echo "$ac_t""no" 1>&6
6024 fi
6025
6026 fi
6027 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
6028    if test -n "$with_build_time_tools"; then
6029   for ncn_progname in objdump; do
6030     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6031 echo "configure:6032: checking for ${ncn_progname} in $with_build_time_tools" >&5
6032     if test -x $with_build_time_tools/${ncn_progname}; then
6033       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6034       echo "$ac_t""yes" 1>&6
6035       break
6036     else
6037       echo "$ac_t""no" 1>&6
6038     fi
6039   done
6040 fi
6041
6042 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
6043   for ncn_progname in objdump; do
6044     if test -n "$ncn_target_tool_prefix"; then
6045       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6046 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6047 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6048 echo "configure:6049: checking for $ac_word" >&5
6049 if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
6050   echo $ac_n "(cached) $ac_c" 1>&6
6051 else
6052   if test -n "$OBJDUMP_FOR_TARGET"; then
6053   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
6054 else
6055   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6056   ac_dummy="$PATH"
6057   for ac_dir in $ac_dummy; do
6058     test -z "$ac_dir" && ac_dir=.
6059     if test -f $ac_dir/$ac_word; then
6060       ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6061       break
6062     fi
6063   done
6064   IFS="$ac_save_ifs"
6065 fi
6066 fi
6067 OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
6068 if test -n "$OBJDUMP_FOR_TARGET"; then
6069   echo "$ac_t""$OBJDUMP_FOR_TARGET" 1>&6
6070 else
6071   echo "$ac_t""no" 1>&6
6072 fi
6073
6074     fi
6075     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
6076       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6077 set dummy ${ncn_progname}; ac_word=$2
6078 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6079 echo "configure:6080: checking for $ac_word" >&5
6080 if eval "test \"`echo '$''{'ac_cv_prog_OBJDUMP_FOR_TARGET'+set}'`\" = set"; then
6081   echo $ac_n "(cached) $ac_c" 1>&6
6082 else
6083   if test -n "$OBJDUMP_FOR_TARGET"; then
6084   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
6085 else
6086   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6087   ac_dummy="$PATH"
6088   for ac_dir in $ac_dummy; do
6089     test -z "$ac_dir" && ac_dir=.
6090     if test -f $ac_dir/$ac_word; then
6091       ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
6092       break
6093     fi
6094   done
6095   IFS="$ac_save_ifs"
6096 fi
6097 fi
6098 OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
6099 if test -n "$OBJDUMP_FOR_TARGET"; then
6100   echo "$ac_t""$OBJDUMP_FOR_TARGET" 1>&6
6101 else
6102   echo "$ac_t""no" 1>&6
6103 fi
6104
6105     fi
6106     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
6107   done
6108 fi
6109
6110 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
6111   set dummy objdump
6112   if test $build = $target ; then
6113     OBJDUMP_FOR_TARGET="$2"
6114   else
6115     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
6116   fi
6117 fi
6118
6119 else
6120   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
6121 fi
6122
6123
6124
6125
6126 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
6127   if test -n "$with_build_time_tools"; then
6128     echo $ac_n "checking for ranlib in $with_build_time_tools""... $ac_c" 1>&6
6129 echo "configure:6130: checking for ranlib in $with_build_time_tools" >&5
6130     if test -x $with_build_time_tools/ranlib; then
6131       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
6132       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
6133       echo "$ac_t""$ac_cv_path_RANLIB_FOR_TARGET" 1>&6
6134     else
6135       echo "$ac_t""no" 1>&6
6136     fi
6137   elif test $build != $host && test $have_gcc_for_target = yes; then
6138     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
6139     test $RANLIB_FOR_TARGET=ranlib && RANLIB_FOR_TARGET=
6140     ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
6141   fi
6142 fi
6143 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
6144   # Extract the first word of "ranlib", so it can be a program name with args.
6145 set dummy ranlib; ac_word=$2
6146 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6147 echo "configure:6148: checking for $ac_word" >&5
6148 if eval "test \"`echo '$''{'ac_cv_path_RANLIB_FOR_TARGET'+set}'`\" = set"; then
6149   echo $ac_n "(cached) $ac_c" 1>&6
6150 else
6151   case "$RANLIB_FOR_TARGET" in
6152   /*)
6153   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
6154   ;;
6155   ?:/*)
6156   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a dos path.
6157   ;;
6158   *)
6159   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6160   ac_dummy="$gcc_cv_tool_dirs"
6161   for ac_dir in $ac_dummy; do
6162     test -z "$ac_dir" && ac_dir=.
6163     if test -f $ac_dir/$ac_word; then
6164       ac_cv_path_RANLIB_FOR_TARGET="$ac_dir/$ac_word"
6165       break
6166     fi
6167   done
6168   IFS="$ac_save_ifs"
6169   ;;
6170 esac
6171 fi
6172 RANLIB_FOR_TARGET="$ac_cv_path_RANLIB_FOR_TARGET"
6173 if test -n "$RANLIB_FOR_TARGET"; then
6174   echo "$ac_t""$RANLIB_FOR_TARGET" 1>&6
6175 else
6176   echo "$ac_t""no" 1>&6
6177 fi
6178
6179 fi
6180 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
6181    if test -n "$with_build_time_tools"; then
6182   for ncn_progname in ranlib; do
6183     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6184 echo "configure:6185: checking for ${ncn_progname} in $with_build_time_tools" >&5
6185     if test -x $with_build_time_tools/${ncn_progname}; then
6186       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6187       echo "$ac_t""yes" 1>&6
6188       break
6189     else
6190       echo "$ac_t""no" 1>&6
6191     fi
6192   done
6193 fi
6194
6195 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
6196   for ncn_progname in ranlib; do
6197     if test -n "$ncn_target_tool_prefix"; then
6198       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6199 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6200 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6201 echo "configure:6202: checking for $ac_word" >&5
6202 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB_FOR_TARGET'+set}'`\" = set"; then
6203   echo $ac_n "(cached) $ac_c" 1>&6
6204 else
6205   if test -n "$RANLIB_FOR_TARGET"; then
6206   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
6207 else
6208   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6209   ac_dummy="$PATH"
6210   for ac_dir in $ac_dummy; do
6211     test -z "$ac_dir" && ac_dir=.
6212     if test -f $ac_dir/$ac_word; then
6213       ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6214       break
6215     fi
6216   done
6217   IFS="$ac_save_ifs"
6218 fi
6219 fi
6220 RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
6221 if test -n "$RANLIB_FOR_TARGET"; then
6222   echo "$ac_t""$RANLIB_FOR_TARGET" 1>&6
6223 else
6224   echo "$ac_t""no" 1>&6
6225 fi
6226
6227     fi
6228     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
6229       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6230 set dummy ${ncn_progname}; ac_word=$2
6231 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6232 echo "configure:6233: checking for $ac_word" >&5
6233 if eval "test \"`echo '$''{'ac_cv_prog_RANLIB_FOR_TARGET'+set}'`\" = set"; then
6234   echo $ac_n "(cached) $ac_c" 1>&6
6235 else
6236   if test -n "$RANLIB_FOR_TARGET"; then
6237   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
6238 else
6239   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6240   ac_dummy="$PATH"
6241   for ac_dir in $ac_dummy; do
6242     test -z "$ac_dir" && ac_dir=.
6243     if test -f $ac_dir/$ac_word; then
6244       ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
6245       break
6246     fi
6247   done
6248   IFS="$ac_save_ifs"
6249 fi
6250 fi
6251 RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
6252 if test -n "$RANLIB_FOR_TARGET"; then
6253   echo "$ac_t""$RANLIB_FOR_TARGET" 1>&6
6254 else
6255   echo "$ac_t""no" 1>&6
6256 fi
6257
6258     fi
6259     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
6260   done
6261 fi
6262
6263 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
6264   set dummy ranlib
6265   if test $build = $target ; then
6266     RANLIB_FOR_TARGET="$2"
6267   else
6268     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
6269   fi
6270 fi
6271
6272 else
6273   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
6274 fi
6275
6276
6277
6278
6279 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
6280   if test -n "$with_build_time_tools"; then
6281     echo $ac_n "checking for strip in $with_build_time_tools""... $ac_c" 1>&6
6282 echo "configure:6283: checking for strip in $with_build_time_tools" >&5
6283     if test -x $with_build_time_tools/strip; then
6284       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
6285       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
6286       echo "$ac_t""$ac_cv_path_STRIP_FOR_TARGET" 1>&6
6287     else
6288       echo "$ac_t""no" 1>&6
6289     fi
6290   elif test $build != $host && test $have_gcc_for_target = yes; then
6291     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
6292     test $STRIP_FOR_TARGET=strip && STRIP_FOR_TARGET=
6293     ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
6294   fi
6295 fi
6296 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
6297   # Extract the first word of "strip", so it can be a program name with args.
6298 set dummy strip; ac_word=$2
6299 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6300 echo "configure:6301: checking for $ac_word" >&5
6301 if eval "test \"`echo '$''{'ac_cv_path_STRIP_FOR_TARGET'+set}'`\" = set"; then
6302   echo $ac_n "(cached) $ac_c" 1>&6
6303 else
6304   case "$STRIP_FOR_TARGET" in
6305   /*)
6306   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
6307   ;;
6308   ?:/*)
6309   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a dos path.
6310   ;;
6311   *)
6312   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6313   ac_dummy="$gcc_cv_tool_dirs"
6314   for ac_dir in $ac_dummy; do
6315     test -z "$ac_dir" && ac_dir=.
6316     if test -f $ac_dir/$ac_word; then
6317       ac_cv_path_STRIP_FOR_TARGET="$ac_dir/$ac_word"
6318       break
6319     fi
6320   done
6321   IFS="$ac_save_ifs"
6322   ;;
6323 esac
6324 fi
6325 STRIP_FOR_TARGET="$ac_cv_path_STRIP_FOR_TARGET"
6326 if test -n "$STRIP_FOR_TARGET"; then
6327   echo "$ac_t""$STRIP_FOR_TARGET" 1>&6
6328 else
6329   echo "$ac_t""no" 1>&6
6330 fi
6331
6332 fi
6333 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
6334    if test -n "$with_build_time_tools"; then
6335   for ncn_progname in strip; do
6336     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6337 echo "configure:6338: checking for ${ncn_progname} in $with_build_time_tools" >&5
6338     if test -x $with_build_time_tools/${ncn_progname}; then
6339       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6340       echo "$ac_t""yes" 1>&6
6341       break
6342     else
6343       echo "$ac_t""no" 1>&6
6344     fi
6345   done
6346 fi
6347
6348 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
6349   for ncn_progname in strip; do
6350     if test -n "$ncn_target_tool_prefix"; then
6351       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6352 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6353 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6354 echo "configure:6355: checking for $ac_word" >&5
6355 if eval "test \"`echo '$''{'ac_cv_prog_STRIP_FOR_TARGET'+set}'`\" = set"; then
6356   echo $ac_n "(cached) $ac_c" 1>&6
6357 else
6358   if test -n "$STRIP_FOR_TARGET"; then
6359   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
6360 else
6361   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6362   ac_dummy="$PATH"
6363   for ac_dir in $ac_dummy; do
6364     test -z "$ac_dir" && ac_dir=.
6365     if test -f $ac_dir/$ac_word; then
6366       ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6367       break
6368     fi
6369   done
6370   IFS="$ac_save_ifs"
6371 fi
6372 fi
6373 STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
6374 if test -n "$STRIP_FOR_TARGET"; then
6375   echo "$ac_t""$STRIP_FOR_TARGET" 1>&6
6376 else
6377   echo "$ac_t""no" 1>&6
6378 fi
6379
6380     fi
6381     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
6382       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6383 set dummy ${ncn_progname}; ac_word=$2
6384 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6385 echo "configure:6386: checking for $ac_word" >&5
6386 if eval "test \"`echo '$''{'ac_cv_prog_STRIP_FOR_TARGET'+set}'`\" = set"; then
6387   echo $ac_n "(cached) $ac_c" 1>&6
6388 else
6389   if test -n "$STRIP_FOR_TARGET"; then
6390   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
6391 else
6392   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6393   ac_dummy="$PATH"
6394   for ac_dir in $ac_dummy; do
6395     test -z "$ac_dir" && ac_dir=.
6396     if test -f $ac_dir/$ac_word; then
6397       ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
6398       break
6399     fi
6400   done
6401   IFS="$ac_save_ifs"
6402 fi
6403 fi
6404 STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
6405 if test -n "$STRIP_FOR_TARGET"; then
6406   echo "$ac_t""$STRIP_FOR_TARGET" 1>&6
6407 else
6408   echo "$ac_t""no" 1>&6
6409 fi
6410
6411     fi
6412     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
6413   done
6414 fi
6415
6416 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
6417   set dummy strip
6418   if test $build = $target ; then
6419     STRIP_FOR_TARGET="$2"
6420   else
6421     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
6422   fi
6423 fi
6424
6425 else
6426   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
6427 fi
6428
6429
6430
6431
6432 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
6433   if test -n "$with_build_time_tools"; then
6434     echo $ac_n "checking for windres in $with_build_time_tools""... $ac_c" 1>&6
6435 echo "configure:6436: checking for windres in $with_build_time_tools" >&5
6436     if test -x $with_build_time_tools/windres; then
6437       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
6438       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
6439       echo "$ac_t""$ac_cv_path_WINDRES_FOR_TARGET" 1>&6
6440     else
6441       echo "$ac_t""no" 1>&6
6442     fi
6443   elif test $build != $host && test $have_gcc_for_target = yes; then
6444     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
6445     test $WINDRES_FOR_TARGET=windres && WINDRES_FOR_TARGET=
6446     ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
6447   fi
6448 fi
6449 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
6450   # Extract the first word of "windres", so it can be a program name with args.
6451 set dummy windres; ac_word=$2
6452 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6453 echo "configure:6454: checking for $ac_word" >&5
6454 if eval "test \"`echo '$''{'ac_cv_path_WINDRES_FOR_TARGET'+set}'`\" = set"; then
6455   echo $ac_n "(cached) $ac_c" 1>&6
6456 else
6457   case "$WINDRES_FOR_TARGET" in
6458   /*)
6459   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
6460   ;;
6461   ?:/*)
6462   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a dos path.
6463   ;;
6464   *)
6465   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6466   ac_dummy="$gcc_cv_tool_dirs"
6467   for ac_dir in $ac_dummy; do
6468     test -z "$ac_dir" && ac_dir=.
6469     if test -f $ac_dir/$ac_word; then
6470       ac_cv_path_WINDRES_FOR_TARGET="$ac_dir/$ac_word"
6471       break
6472     fi
6473   done
6474   IFS="$ac_save_ifs"
6475   ;;
6476 esac
6477 fi
6478 WINDRES_FOR_TARGET="$ac_cv_path_WINDRES_FOR_TARGET"
6479 if test -n "$WINDRES_FOR_TARGET"; then
6480   echo "$ac_t""$WINDRES_FOR_TARGET" 1>&6
6481 else
6482   echo "$ac_t""no" 1>&6
6483 fi
6484
6485 fi
6486 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
6487    if test -n "$with_build_time_tools"; then
6488   for ncn_progname in windres; do
6489     echo $ac_n "checking for ${ncn_progname} in $with_build_time_tools""... $ac_c" 1>&6
6490 echo "configure:6491: checking for ${ncn_progname} in $with_build_time_tools" >&5
6491     if test -x $with_build_time_tools/${ncn_progname}; then
6492       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
6493       echo "$ac_t""yes" 1>&6
6494       break
6495     else
6496       echo "$ac_t""no" 1>&6
6497     fi
6498   done
6499 fi
6500
6501 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
6502   for ncn_progname in windres; do
6503     if test -n "$ncn_target_tool_prefix"; then
6504       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
6505 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
6506 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6507 echo "configure:6508: checking for $ac_word" >&5
6508 if eval "test \"`echo '$''{'ac_cv_prog_WINDRES_FOR_TARGET'+set}'`\" = set"; then
6509   echo $ac_n "(cached) $ac_c" 1>&6
6510 else
6511   if test -n "$WINDRES_FOR_TARGET"; then
6512   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
6513 else
6514   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6515   ac_dummy="$PATH"
6516   for ac_dir in $ac_dummy; do
6517     test -z "$ac_dir" && ac_dir=.
6518     if test -f $ac_dir/$ac_word; then
6519       ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
6520       break
6521     fi
6522   done
6523   IFS="$ac_save_ifs"
6524 fi
6525 fi
6526 WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
6527 if test -n "$WINDRES_FOR_TARGET"; then
6528   echo "$ac_t""$WINDRES_FOR_TARGET" 1>&6
6529 else
6530   echo "$ac_t""no" 1>&6
6531 fi
6532
6533     fi
6534     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
6535       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6536 set dummy ${ncn_progname}; ac_word=$2
6537 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
6538 echo "configure:6539: checking for $ac_word" >&5
6539 if eval "test \"`echo '$''{'ac_cv_prog_WINDRES_FOR_TARGET'+set}'`\" = set"; then
6540   echo $ac_n "(cached) $ac_c" 1>&6
6541 else
6542   if test -n "$WINDRES_FOR_TARGET"; then
6543   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
6544 else
6545   IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
6546   ac_dummy="$PATH"
6547   for ac_dir in $ac_dummy; do
6548     test -z "$ac_dir" && ac_dir=.
6549     if test -f $ac_dir/$ac_word; then
6550       ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
6551       break
6552     fi
6553   done
6554   IFS="$ac_save_ifs"
6555 fi
6556 fi
6557 WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
6558 if test -n "$WINDRES_FOR_TARGET"; then
6559   echo "$ac_t""$WINDRES_FOR_TARGET" 1>&6
6560 else
6561   echo "$ac_t""no" 1>&6
6562 fi
6563
6564     fi
6565     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
6566   done
6567 fi
6568
6569 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
6570   set dummy windres
6571   if test $build = $target ; then
6572     WINDRES_FOR_TARGET="$2"
6573   else
6574     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
6575   fi
6576 fi
6577
6578 else
6579   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
6580 fi
6581
6582
6583 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
6584
6585 echo $ac_n "checking where to find the target ar""... $ac_c" 1>&6
6586 echo "configure:6587: checking where to find the target ar" >&5
6587 if test "x${build}" != "x${host}" ; then
6588   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
6589     # We already found the complete path
6590     echo "$ac_t""pre-installed in `dirname $AR_FOR_TARGET`" 1>&6
6591   else
6592     # Canadian cross, just use what we found
6593     echo "$ac_t""pre-installed" 1>&6
6594   fi
6595 else
6596   ok=yes
6597   case " ${configdirs} " in
6598     *" binutils "*) ;;
6599     *) ok=no ;;
6600   esac
6601
6602   if test $ok = yes; then
6603     # An in-tree tool is available and we can use it
6604     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
6605     echo "$ac_t""just compiled" 1>&6
6606   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
6607     # We already found the complete path
6608     echo "$ac_t""pre-installed in `dirname $AR_FOR_TARGET`" 1>&6
6609   elif test "x$target" = "x$host"; then
6610     # We can use an host tool
6611     AR_FOR_TARGET='$(AR)'
6612     echo "$ac_t""host tool" 1>&6
6613   else
6614     # We need a cross tool
6615     echo "$ac_t""pre-installed" 1>&6
6616   fi
6617 fi
6618 echo $ac_n "checking where to find the target as""... $ac_c" 1>&6
6619 echo "configure:6620: checking where to find the target as" >&5
6620 if test "x${build}" != "x${host}" ; then
6621   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
6622     # We already found the complete path
6623     echo "$ac_t""pre-installed in `dirname $AS_FOR_TARGET`" 1>&6
6624   else
6625     # Canadian cross, just use what we found
6626     echo "$ac_t""pre-installed" 1>&6
6627   fi
6628 else
6629   ok=yes
6630   case " ${configdirs} " in
6631     *" gas "*) ;;
6632     *) ok=no ;;
6633   esac
6634
6635   if test $ok = yes; then
6636     # An in-tree tool is available and we can use it
6637     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
6638     echo "$ac_t""just compiled" 1>&6
6639   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
6640     # We already found the complete path
6641     echo "$ac_t""pre-installed in `dirname $AS_FOR_TARGET`" 1>&6
6642   elif test "x$target" = "x$host"; then
6643     # We can use an host tool
6644     AS_FOR_TARGET='$(AS)'
6645     echo "$ac_t""host tool" 1>&6
6646   else
6647     # We need a cross tool
6648     echo "$ac_t""pre-installed" 1>&6
6649   fi
6650 fi
6651 echo $ac_n "checking where to find the target cc""... $ac_c" 1>&6
6652 echo "configure:6653: checking where to find the target cc" >&5
6653 if test "x${build}" != "x${host}" ; then
6654   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
6655     # We already found the complete path
6656     echo "$ac_t""pre-installed in `dirname $CC_FOR_TARGET`" 1>&6
6657   else
6658     # Canadian cross, just use what we found
6659     echo "$ac_t""pre-installed" 1>&6
6660   fi
6661 else
6662   ok=yes
6663   case " ${configdirs} " in
6664     *" gcc "*) ;;
6665     *) ok=no ;;
6666   esac
6667
6668   if test $ok = yes; then
6669     # An in-tree tool is available and we can use it
6670     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
6671     echo "$ac_t""just compiled" 1>&6
6672   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
6673     # We already found the complete path
6674     echo "$ac_t""pre-installed in `dirname $CC_FOR_TARGET`" 1>&6
6675   elif test "x$target" = "x$host"; then
6676     # We can use an host tool
6677     CC_FOR_TARGET='$(CC)'
6678     echo "$ac_t""host tool" 1>&6
6679   else
6680     # We need a cross tool
6681     echo "$ac_t""pre-installed" 1>&6
6682   fi
6683 fi
6684 echo $ac_n "checking where to find the target c++""... $ac_c" 1>&6
6685 echo "configure:6686: checking where to find the target c++" >&5
6686 if test "x${build}" != "x${host}" ; then
6687   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
6688     # We already found the complete path
6689     echo "$ac_t""pre-installed in `dirname $CXX_FOR_TARGET`" 1>&6
6690   else
6691     # Canadian cross, just use what we found
6692     echo "$ac_t""pre-installed" 1>&6
6693   fi
6694 else
6695   ok=yes
6696   case " ${configdirs} " in
6697     *" gcc "*) ;;
6698     *) ok=no ;;
6699   esac
6700   case ,${enable_languages}, in
6701     *,c++,*) ;;
6702     *) ok=no ;;
6703   esac
6704   if test $ok = yes; then
6705     # An in-tree tool is available and we can use it
6706     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'
6707     echo "$ac_t""just compiled" 1>&6
6708   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
6709     # We already found the complete path
6710     echo "$ac_t""pre-installed in `dirname $CXX_FOR_TARGET`" 1>&6
6711   elif test "x$target" = "x$host"; then
6712     # We can use an host tool
6713     CXX_FOR_TARGET='$(CXX)'
6714     echo "$ac_t""host tool" 1>&6
6715   else
6716     # We need a cross tool
6717     echo "$ac_t""pre-installed" 1>&6
6718   fi
6719 fi
6720 echo $ac_n "checking where to find the target c++ for libstdc++""... $ac_c" 1>&6
6721 echo "configure:6722: checking where to find the target c++ for libstdc++" >&5
6722 if test "x${build}" != "x${host}" ; then
6723   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
6724     # We already found the complete path
6725     echo "$ac_t""pre-installed in `dirname $RAW_CXX_FOR_TARGET`" 1>&6
6726   else
6727     # Canadian cross, just use what we found
6728     echo "$ac_t""pre-installed" 1>&6
6729   fi
6730 else
6731   ok=yes
6732   case " ${configdirs} " in
6733     *" gcc "*) ;;
6734     *) ok=no ;;
6735   esac
6736   case ,${enable_languages}, in
6737     *,c++,*) ;;
6738     *) ok=no ;;
6739   esac
6740   if test $ok = yes; then
6741     # An in-tree tool is available and we can use it
6742     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'
6743     echo "$ac_t""just compiled" 1>&6
6744   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
6745     # We already found the complete path
6746     echo "$ac_t""pre-installed in `dirname $RAW_CXX_FOR_TARGET`" 1>&6
6747   elif test "x$target" = "x$host"; then
6748     # We can use an host tool
6749     RAW_CXX_FOR_TARGET='$(CXX)'
6750     echo "$ac_t""host tool" 1>&6
6751   else
6752     # We need a cross tool
6753     echo "$ac_t""pre-installed" 1>&6
6754   fi
6755 fi
6756 echo $ac_n "checking where to find the target dlltool""... $ac_c" 1>&6
6757 echo "configure:6758: checking where to find the target dlltool" >&5
6758 if test "x${build}" != "x${host}" ; then
6759   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
6760     # We already found the complete path
6761     echo "$ac_t""pre-installed in `dirname $DLLTOOL_FOR_TARGET`" 1>&6
6762   else
6763     # Canadian cross, just use what we found
6764     echo "$ac_t""pre-installed" 1>&6
6765   fi
6766 else
6767   ok=yes
6768   case " ${configdirs} " in
6769     *" binutils "*) ;;
6770     *) ok=no ;;
6771   esac
6772
6773   if test $ok = yes; then
6774     # An in-tree tool is available and we can use it
6775     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
6776     echo "$ac_t""just compiled" 1>&6
6777   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
6778     # We already found the complete path
6779     echo "$ac_t""pre-installed in `dirname $DLLTOOL_FOR_TARGET`" 1>&6
6780   elif test "x$target" = "x$host"; then
6781     # We can use an host tool
6782     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
6783     echo "$ac_t""host tool" 1>&6
6784   else
6785     # We need a cross tool
6786     echo "$ac_t""pre-installed" 1>&6
6787   fi
6788 fi
6789 echo $ac_n "checking where to find the target gcc""... $ac_c" 1>&6
6790 echo "configure:6791: checking where to find the target gcc" >&5
6791 if test "x${build}" != "x${host}" ; then
6792   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
6793     # We already found the complete path
6794     echo "$ac_t""pre-installed in `dirname $GCC_FOR_TARGET`" 1>&6
6795   else
6796     # Canadian cross, just use what we found
6797     echo "$ac_t""pre-installed" 1>&6
6798   fi
6799 else
6800   ok=yes
6801   case " ${configdirs} " in
6802     *" gcc "*) ;;
6803     *) ok=no ;;
6804   esac
6805
6806   if test $ok = yes; then
6807     # An in-tree tool is available and we can use it
6808     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
6809     echo "$ac_t""just compiled" 1>&6
6810   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
6811     # We already found the complete path
6812     echo "$ac_t""pre-installed in `dirname $GCC_FOR_TARGET`" 1>&6
6813   elif test "x$target" = "x$host"; then
6814     # We can use an host tool
6815     GCC_FOR_TARGET='$()'
6816     echo "$ac_t""host tool" 1>&6
6817   else
6818     # We need a cross tool
6819     echo "$ac_t""pre-installed" 1>&6
6820   fi
6821 fi
6822 echo $ac_n "checking where to find the target gcj""... $ac_c" 1>&6
6823 echo "configure:6824: checking where to find the target gcj" >&5
6824 if test "x${build}" != "x${host}" ; then
6825   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
6826     # We already found the complete path
6827     echo "$ac_t""pre-installed in `dirname $GCJ_FOR_TARGET`" 1>&6
6828   else
6829     # Canadian cross, just use what we found
6830     echo "$ac_t""pre-installed" 1>&6
6831   fi
6832 else
6833   ok=yes
6834   case " ${configdirs} " in
6835     *" gcc "*) ;;
6836     *) ok=no ;;
6837   esac
6838   case ,${enable_languages}, in
6839     *,java,*) ;;
6840     *) ok=no ;;
6841   esac
6842   if test $ok = yes; then
6843     # An in-tree tool is available and we can use it
6844     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
6845     echo "$ac_t""just compiled" 1>&6
6846   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
6847     # We already found the complete path
6848     echo "$ac_t""pre-installed in `dirname $GCJ_FOR_TARGET`" 1>&6
6849   elif test "x$target" = "x$host"; then
6850     # We can use an host tool
6851     GCJ_FOR_TARGET='$(GCJ)'
6852     echo "$ac_t""host tool" 1>&6
6853   else
6854     # We need a cross tool
6855     echo "$ac_t""pre-installed" 1>&6
6856   fi
6857 fi
6858 echo $ac_n "checking where to find the target gfortran""... $ac_c" 1>&6
6859 echo "configure:6860: checking where to find the target gfortran" >&5
6860 if test "x${build}" != "x${host}" ; then
6861   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
6862     # We already found the complete path
6863     echo "$ac_t""pre-installed in `dirname $GFORTRAN_FOR_TARGET`" 1>&6
6864   else
6865     # Canadian cross, just use what we found
6866     echo "$ac_t""pre-installed" 1>&6
6867   fi
6868 else
6869   ok=yes
6870   case " ${configdirs} " in
6871     *" gcc "*) ;;
6872     *) ok=no ;;
6873   esac
6874   case ,${enable_languages}, in
6875     *,fortran,*) ;;
6876     *) ok=no ;;
6877   esac
6878   if test $ok = yes; then
6879     # An in-tree tool is available and we can use it
6880     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
6881     echo "$ac_t""just compiled" 1>&6
6882   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
6883     # We already found the complete path
6884     echo "$ac_t""pre-installed in `dirname $GFORTRAN_FOR_TARGET`" 1>&6
6885   elif test "x$target" = "x$host"; then
6886     # We can use an host tool
6887     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
6888     echo "$ac_t""host tool" 1>&6
6889   else
6890     # We need a cross tool
6891     echo "$ac_t""pre-installed" 1>&6
6892   fi
6893 fi
6894 echo $ac_n "checking where to find the target ld""... $ac_c" 1>&6
6895 echo "configure:6896: checking where to find the target ld" >&5
6896 if test "x${build}" != "x${host}" ; then
6897   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
6898     # We already found the complete path
6899     echo "$ac_t""pre-installed in `dirname $LD_FOR_TARGET`" 1>&6
6900   else
6901     # Canadian cross, just use what we found
6902     echo "$ac_t""pre-installed" 1>&6
6903   fi
6904 else
6905   ok=yes
6906   case " ${configdirs} " in
6907     *" ld "*) ;;
6908     *) ok=no ;;
6909   esac
6910
6911   if test $ok = yes; then
6912     # An in-tree tool is available and we can use it
6913     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
6914     echo "$ac_t""just compiled" 1>&6
6915   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
6916     # We already found the complete path
6917     echo "$ac_t""pre-installed in `dirname $LD_FOR_TARGET`" 1>&6
6918   elif test "x$target" = "x$host"; then
6919     # We can use an host tool
6920     LD_FOR_TARGET='$(LD)'
6921     echo "$ac_t""host tool" 1>&6
6922   else
6923     # We need a cross tool
6924     echo "$ac_t""pre-installed" 1>&6
6925   fi
6926 fi
6927 echo $ac_n "checking where to find the target lipo""... $ac_c" 1>&6
6928 echo "configure:6929: checking where to find the target lipo" >&5
6929 if test "x${build}" != "x${host}" ; then
6930   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
6931     # We already found the complete path
6932     echo "$ac_t""pre-installed in `dirname $LIPO_FOR_TARGET`" 1>&6
6933   else
6934     # Canadian cross, just use what we found
6935     echo "$ac_t""pre-installed" 1>&6
6936   fi
6937 else
6938   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
6939     # We already found the complete path
6940     echo "$ac_t""pre-installed in `dirname $LIPO_FOR_TARGET`" 1>&6
6941   elif test "x$target" = "x$host"; then
6942     # We can use an host tool
6943     LIPO_FOR_TARGET='$(LIPO)'
6944     echo "$ac_t""host tool" 1>&6
6945   else
6946     # We need a cross tool
6947     echo "$ac_t""pre-installed" 1>&6
6948   fi
6949 fi
6950 echo $ac_n "checking where to find the target nm""... $ac_c" 1>&6
6951 echo "configure:6952: checking where to find the target nm" >&5
6952 if test "x${build}" != "x${host}" ; then
6953   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
6954     # We already found the complete path
6955     echo "$ac_t""pre-installed in `dirname $NM_FOR_TARGET`" 1>&6
6956   else
6957     # Canadian cross, just use what we found
6958     echo "$ac_t""pre-installed" 1>&6
6959   fi
6960 else
6961   ok=yes
6962   case " ${configdirs} " in
6963     *" binutils "*) ;;
6964     *) ok=no ;;
6965   esac
6966
6967   if test $ok = yes; then
6968     # An in-tree tool is available and we can use it
6969     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
6970     echo "$ac_t""just compiled" 1>&6
6971   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
6972     # We already found the complete path
6973     echo "$ac_t""pre-installed in `dirname $NM_FOR_TARGET`" 1>&6
6974   elif test "x$target" = "x$host"; then
6975     # We can use an host tool
6976     NM_FOR_TARGET='$(NM)'
6977     echo "$ac_t""host tool" 1>&6
6978   else
6979     # We need a cross tool
6980     echo "$ac_t""pre-installed" 1>&6
6981   fi
6982 fi
6983 echo $ac_n "checking where to find the target objdump""... $ac_c" 1>&6
6984 echo "configure:6985: checking where to find the target objdump" >&5
6985 if test "x${build}" != "x${host}" ; then
6986   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
6987     # We already found the complete path
6988     echo "$ac_t""pre-installed in `dirname $OBJDUMP_FOR_TARGET`" 1>&6
6989   else
6990     # Canadian cross, just use what we found
6991     echo "$ac_t""pre-installed" 1>&6
6992   fi
6993 else
6994   ok=yes
6995   case " ${configdirs} " in
6996     *" binutils "*) ;;
6997     *) ok=no ;;
6998   esac
6999
7000   if test $ok = yes; then
7001     # An in-tree tool is available and we can use it
7002     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
7003     echo "$ac_t""just compiled" 1>&6
7004   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
7005     # We already found the complete path
7006     echo "$ac_t""pre-installed in `dirname $OBJDUMP_FOR_TARGET`" 1>&6
7007   elif test "x$target" = "x$host"; then
7008     # We can use an host tool
7009     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
7010     echo "$ac_t""host tool" 1>&6
7011   else
7012     # We need a cross tool
7013     echo "$ac_t""pre-installed" 1>&6
7014   fi
7015 fi
7016 echo $ac_n "checking where to find the target ranlib""... $ac_c" 1>&6
7017 echo "configure:7018: checking where to find the target ranlib" >&5
7018 if test "x${build}" != "x${host}" ; then
7019   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
7020     # We already found the complete path
7021     echo "$ac_t""pre-installed in `dirname $RANLIB_FOR_TARGET`" 1>&6
7022   else
7023     # Canadian cross, just use what we found
7024     echo "$ac_t""pre-installed" 1>&6
7025   fi
7026 else
7027   ok=yes
7028   case " ${configdirs} " in
7029     *" binutils "*) ;;
7030     *) ok=no ;;
7031   esac
7032
7033   if test $ok = yes; then
7034     # An in-tree tool is available and we can use it
7035     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
7036     echo "$ac_t""just compiled" 1>&6
7037   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
7038     # We already found the complete path
7039     echo "$ac_t""pre-installed in `dirname $RANLIB_FOR_TARGET`" 1>&6
7040   elif test "x$target" = "x$host"; then
7041     # We can use an host tool
7042     RANLIB_FOR_TARGET='$(RANLIB)'
7043     echo "$ac_t""host tool" 1>&6
7044   else
7045     # We need a cross tool
7046     echo "$ac_t""pre-installed" 1>&6
7047   fi
7048 fi
7049 echo $ac_n "checking where to find the target strip""... $ac_c" 1>&6
7050 echo "configure:7051: checking where to find the target strip" >&5
7051 if test "x${build}" != "x${host}" ; then
7052   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
7053     # We already found the complete path
7054     echo "$ac_t""pre-installed in `dirname $STRIP_FOR_TARGET`" 1>&6
7055   else
7056     # Canadian cross, just use what we found
7057     echo "$ac_t""pre-installed" 1>&6
7058   fi
7059 else
7060   ok=yes
7061   case " ${configdirs} " in
7062     *" binutils "*) ;;
7063     *) ok=no ;;
7064   esac
7065
7066   if test $ok = yes; then
7067     # An in-tree tool is available and we can use it
7068     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
7069     echo "$ac_t""just compiled" 1>&6
7070   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
7071     # We already found the complete path
7072     echo "$ac_t""pre-installed in `dirname $STRIP_FOR_TARGET`" 1>&6
7073   elif test "x$target" = "x$host"; then
7074     # We can use an host tool
7075     STRIP_FOR_TARGET='$(STRIP)'
7076     echo "$ac_t""host tool" 1>&6
7077   else
7078     # We need a cross tool
7079     echo "$ac_t""pre-installed" 1>&6
7080   fi
7081 fi
7082 echo $ac_n "checking where to find the target windres""... $ac_c" 1>&6
7083 echo "configure:7084: checking where to find the target windres" >&5
7084 if test "x${build}" != "x${host}" ; then
7085   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
7086     # We already found the complete path
7087     echo "$ac_t""pre-installed in `dirname $WINDRES_FOR_TARGET`" 1>&6
7088   else
7089     # Canadian cross, just use what we found
7090     echo "$ac_t""pre-installed" 1>&6
7091   fi
7092 else
7093   ok=yes
7094   case " ${configdirs} " in
7095     *" binutils "*) ;;
7096     *) ok=no ;;
7097   esac
7098
7099   if test $ok = yes; then
7100     # An in-tree tool is available and we can use it
7101     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
7102     echo "$ac_t""just compiled" 1>&6
7103   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
7104     # We already found the complete path
7105     echo "$ac_t""pre-installed in `dirname $WINDRES_FOR_TARGET`" 1>&6
7106   elif test "x$target" = "x$host"; then
7107     # We can use an host tool
7108     WINDRES_FOR_TARGET='$(WINDRES)'
7109     echo "$ac_t""host tool" 1>&6
7110   else
7111     # We need a cross tool
7112     echo "$ac_t""pre-installed" 1>&6
7113   fi
7114 fi
7115
7116
7117
7118
7119 # Certain tools may need extra flags.
7120 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
7121 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
7122 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
7123
7124 # When building target libraries, except in a Canadian cross, we use
7125 # the same toolchain as the compiler we just built.
7126 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
7127 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
7128 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
7129 if test $host = $build; then
7130   case " $configdirs " in
7131     *" gcc "*)
7132       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
7133       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
7134       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
7135       ;;
7136   esac
7137 fi
7138
7139
7140
7141
7142
7143 echo $ac_n "checking whether to enable maintainer-specific portions of Makefiles""... $ac_c" 1>&6
7144 echo "configure:7145: checking whether to enable maintainer-specific portions of Makefiles" >&5
7145 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
7146 if test "${enable_maintainer_mode+set}" = set; then
7147   enableval="$enable_maintainer_mode"
7148   USE_MAINTAINER_MODE=$enableval
7149 else
7150   USE_MAINTAINER_MODE=no
7151 fi
7152
7153 echo "$ac_t""$USE_MAINTAINER_MODE" 1>&6
7154
7155
7156 if test "$USE_MAINTAINER_MODE" = yes; then
7157   MAINTAINER_MODE_TRUE=
7158   MAINTAINER_MODE_FALSE='#'
7159 else
7160   MAINTAINER_MODE_TRUE='#'
7161   MAINTAINER_MODE_FALSE=
7162 fi
7163 MAINT=$MAINTAINER_MODE_TRUE
7164
7165 # ---------------------
7166 # GCC bootstrap support
7167 # ---------------------
7168
7169 # Stage specific cflags for build.
7170 stage1_cflags="-g"
7171 case $build in
7172   vax-*-*)
7173     case ${GCC} in
7174       yes) stage1_cflags="-g -Wa,-J" ;;
7175       *) stage1_cflags="-g -J" ;;
7176     esac ;;
7177   powerpc-*-darwin*)
7178     # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
7179     # sources; use -no-cpp-precomp to get to GNU cpp.
7180     # Apple's GCC has bugs in designated initializer handling, so disable
7181     # that too.
7182     stage1_cflags="-g -no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
7183     ;;
7184 esac
7185
7186
7187 # Enable -Werror in bootstrap stage2 and later.
7188 # Change the default to "no" on release branches.
7189 # Check whether --enable-werror or --disable-werror was given.
7190 if test "${enable_werror+set}" = set; then
7191   enableval="$enable_werror"
7192   :
7193 else
7194   enable_werror=yes
7195 fi
7196
7197 case ${enable_werror} in
7198   yes) stage2_werror_flag="--enable-werror-always" ;;
7199   *) stage2_werror_flag="" ;;
7200 esac
7201
7202
7203 trap '' 1 2 15
7204 cat > confcache <<\EOF
7205 # This file is a shell script that caches the results of configure
7206 # tests run on this system so they can be shared between configure
7207 # scripts and configure runs.  It is not useful on other systems.
7208 # If it contains results you don't want to keep, you may remove or edit it.
7209 #
7210 # By default, configure uses ./config.cache as the cache file,
7211 # creating it if it does not exist already.  You can give configure
7212 # the --cache-file=FILE option to use a different cache file; that is
7213 # what configure does when it calls configure scripts in
7214 # subdirectories, so they share the cache.
7215 # Giving --cache-file=/dev/null disables caching, for debugging configure.
7216 # config.status only pays attention to the cache file if you give it the
7217 # --recheck option to rerun configure.
7218 #
7219 EOF
7220 # The following way of writing the cache mishandles newlines in values,
7221 # but we know of no workaround that is simple, portable, and efficient.
7222 # So, don't put newlines in cache variables' values.
7223 # Ultrix sh set writes to stderr and can't be redirected directly,
7224 # and sets the high bit in the cache file unless we assign to the vars.
7225 (set) 2>&1 |
7226   case `(ac_space=' '; set | grep ac_space) 2>&1` in
7227   *ac_space=\ *)
7228     # `set' does not quote correctly, so add quotes (double-quote substitution
7229     # turns \\\\ into \\, and sed turns \\ into \).
7230     sed -n \
7231       -e "s/'/'\\\\''/g" \
7232       -e "s/^\\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\\)=\\(.*\\)/\\1=\${\\1='\\2'}/p"
7233     ;;
7234   *)
7235     # `set' quotes correctly as required by POSIX, so do not add quotes.
7236     sed -n -e 's/^\([a-zA-Z0-9_]*_cv_[a-zA-Z0-9_]*\)=\(.*\)/\1=${\1=\2}/p'
7237     ;;
7238   esac >> confcache
7239 if cmp -s $cache_file confcache; then
7240   :
7241 else
7242   if test -w $cache_file; then
7243     echo "updating cache $cache_file"
7244     cat confcache > $cache_file
7245   else
7246     echo "not updating unwritable cache $cache_file"
7247   fi
7248 fi
7249 rm -f confcache
7250
7251 trap 'rm -fr conftest* confdefs* core core.* *.core $ac_clean_files; exit 1' 1 2 15
7252
7253 test "x$prefix" = xNONE && prefix=$ac_default_prefix
7254 # Let make expand exec_prefix.
7255 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
7256
7257 # Any assignment to VPATH causes Sun make to only execute
7258 # the first set of double-colon rules, so remove it if not needed.
7259 # If there is a colon in the path, we need to keep it.
7260 if test "x$srcdir" = x.; then
7261   ac_vpsub='/^[         ]*VPATH[        ]*=[^:]*$/d'
7262 fi
7263
7264 trap 'rm -f $CONFIG_STATUS conftest*; exit 1' 1 2 15
7265
7266 # Transform confdefs.h into DEFS.
7267 # Protect against shell expansion while executing Makefile rules.
7268 # Protect against Makefile macro expansion.
7269 cat > conftest.defs <<\EOF
7270 s%#define \([A-Za-z_][A-Za-z0-9_]*\) *\(.*\)%-D\1=\2%g
7271 s%[     `~#$^&*(){}\\|;'"<>?]%\\&%g
7272 s%\[%\\&%g
7273 s%\]%\\&%g
7274 s%\$%$$%g
7275 EOF
7276 DEFS=`sed -f conftest.defs confdefs.h | tr '\012' ' '`
7277 rm -f conftest.defs
7278
7279
7280 # Without the "./", some shells look in PATH for config.status.
7281 : ${CONFIG_STATUS=./config.status}
7282
7283 echo creating $CONFIG_STATUS
7284 rm -f $CONFIG_STATUS
7285 cat > $CONFIG_STATUS <<EOF
7286 #! /bin/sh
7287 # Generated automatically by configure.
7288 # Run this file to recreate the current configuration.
7289 # This directory was configured as follows,
7290 # on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
7291 #
7292 # $0 $ac_configure_args
7293 #
7294 # Compiler output produced by configure, useful for debugging
7295 # configure, is in ./config.log if it exists.
7296
7297 ac_cs_usage="Usage: $CONFIG_STATUS [--recheck] [--version] [--help]"
7298 for ac_option
7299 do
7300   case "\$ac_option" in
7301   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
7302     echo "running \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion"
7303     exec \${CONFIG_SHELL-/bin/sh} $0 $ac_configure_args --no-create --no-recursion ;;
7304   -version | --version | --versio | --versi | --vers | --ver | --ve | --v)
7305     echo "$CONFIG_STATUS generated by autoconf version 2.13"
7306     exit 0 ;;
7307   -help | --help | --hel | --he | --h)
7308     echo "\$ac_cs_usage"; exit 0 ;;
7309   *) echo "\$ac_cs_usage"; exit 1 ;;
7310   esac
7311 done
7312
7313 ac_given_srcdir=$srcdir
7314 ac_given_INSTALL="$INSTALL"
7315
7316 trap 'rm -fr `echo "Makefile" | sed "s/:[^ ]*//g"` conftest*; exit 1' 1 2 15
7317 EOF
7318 cat >> $CONFIG_STATUS <<EOF
7319
7320 # Protect against being on the right side of a sed subst in config.status.
7321 sed 's/%@/@@/; s/@%/@@/; s/%g\$/@g/; /@g\$/s/[\\\\&%]/\\\\&/g;
7322  s/@@/%@/; s/@@/@%/; s/@g\$/%g/' > conftest.subs <<\\CEOF
7323 $ac_vpsub
7324 $extrasub
7325 s%@SHELL@%$SHELL%g
7326 s%@CFLAGS@%$CFLAGS%g
7327 s%@CPPFLAGS@%$CPPFLAGS%g
7328 s%@CXXFLAGS@%$CXXFLAGS%g
7329 s%@FFLAGS@%$FFLAGS%g
7330 s%@DEFS@%$DEFS%g
7331 s%@LDFLAGS@%$LDFLAGS%g
7332 s%@LIBS@%$LIBS%g
7333 s%@exec_prefix@%$exec_prefix%g
7334 s%@prefix@%$prefix%g
7335 s%@program_transform_name@%$program_transform_name%g
7336 s%@bindir@%$bindir%g
7337 s%@sbindir@%$sbindir%g
7338 s%@libexecdir@%$libexecdir%g
7339 s%@datadir@%$datadir%g
7340 s%@sysconfdir@%$sysconfdir%g
7341 s%@sharedstatedir@%$sharedstatedir%g
7342 s%@localstatedir@%$localstatedir%g
7343 s%@libdir@%$libdir%g
7344 s%@includedir@%$includedir%g
7345 s%@oldincludedir@%$oldincludedir%g
7346 s%@infodir@%$infodir%g
7347 s%@mandir@%$mandir%g
7348 s%@host@%$host%g
7349 s%@host_alias@%$host_alias%g
7350 s%@host_cpu@%$host_cpu%g
7351 s%@host_vendor@%$host_vendor%g
7352 s%@host_os@%$host_os%g
7353 s%@target@%$target%g
7354 s%@target_alias@%$target_alias%g
7355 s%@target_cpu@%$target_cpu%g
7356 s%@target_vendor@%$target_vendor%g
7357 s%@target_os@%$target_os%g
7358 s%@build@%$build%g
7359 s%@build_alias@%$build_alias%g
7360 s%@build_cpu@%$build_cpu%g
7361 s%@build_vendor@%$build_vendor%g
7362 s%@build_os@%$build_os%g
7363 s%@INSTALL_PROGRAM@%$INSTALL_PROGRAM%g
7364 s%@INSTALL_SCRIPT@%$INSTALL_SCRIPT%g
7365 s%@INSTALL_DATA@%$INSTALL_DATA%g
7366 s%@LN@%$LN%g
7367 s%@LN_S@%$LN_S%g
7368 s%@TOPLEVEL_CONFIGURE_ARGUMENTS@%$TOPLEVEL_CONFIGURE_ARGUMENTS%g
7369 s%@build_subdir@%$build_subdir%g
7370 s%@host_subdir@%$host_subdir%g
7371 s%@target_subdir@%$target_subdir%g
7372 s%@CC@%$CC%g
7373 s%@GNATBIND@%$GNATBIND%g
7374 s%@do_compare@%$do_compare%g
7375 s%@gmplibs@%$gmplibs%g
7376 s%@gmpinc@%$gmpinc%g
7377 s%@stage1_languages@%$stage1_languages%g
7378 s%@SYSROOT_CFLAGS_FOR_TARGET@%$SYSROOT_CFLAGS_FOR_TARGET%g
7379 /@serialization_dependencies@/r $serialization_dependencies
7380 s%@serialization_dependencies@%%g
7381 /@host_makefile_frag@/r $host_makefile_frag
7382 s%@host_makefile_frag@%%g
7383 /@target_makefile_frag@/r $target_makefile_frag
7384 s%@target_makefile_frag@%%g
7385 /@alphaieee_frag@/r $alphaieee_frag
7386 s%@alphaieee_frag@%%g
7387 /@ospace_frag@/r $ospace_frag
7388 s%@ospace_frag@%%g
7389 s%@RPATH_ENVVAR@%$RPATH_ENVVAR%g
7390 s%@BUILD_PREFIX@%$BUILD_PREFIX%g
7391 s%@BUILD_PREFIX_1@%$BUILD_PREFIX_1%g
7392 s%@tooldir@%$tooldir%g
7393 s%@build_tooldir@%$build_tooldir%g
7394 s%@CONFIGURE_GDB_TK@%$CONFIGURE_GDB_TK%g
7395 s%@GDB_TK@%$GDB_TK%g
7396 s%@INSTALL_GDB_TK@%$INSTALL_GDB_TK%g
7397 s%@build_configargs@%$build_configargs%g
7398 s%@build_configdirs@%$build_configdirs%g
7399 s%@host_configargs@%$host_configargs%g
7400 s%@configdirs@%$configdirs%g
7401 s%@target_configargs@%$target_configargs%g
7402 s%@target_configdirs@%$target_configdirs%g
7403 s%@CC_FOR_BUILD@%$CC_FOR_BUILD%g
7404 s%@config_shell@%$config_shell%g
7405 s%@YACC@%$YACC%g
7406 s%@BISON@%$BISON%g
7407 s%@M4@%$M4%g
7408 s%@LEX@%$LEX%g
7409 s%@FLEX@%$FLEX%g
7410 s%@MAKEINFO@%$MAKEINFO%g
7411 s%@EXPECT@%$EXPECT%g
7412 s%@RUNTEST@%$RUNTEST%g
7413 s%@AR@%$AR%g
7414 s%@AS@%$AS%g
7415 s%@DLLTOOL@%$DLLTOOL%g
7416 s%@LD@%$LD%g
7417 s%@LIPO@%$LIPO%g
7418 s%@NM@%$NM%g
7419 s%@RANLIB@%$RANLIB%g
7420 s%@STRIP@%$STRIP%g
7421 s%@WINDRES@%$WINDRES%g
7422 s%@OBJCOPY@%$OBJCOPY%g
7423 s%@OBJDUMP@%$OBJDUMP%g
7424 s%@CXX@%$CXX%g
7425 s%@CFLAGS_FOR_BUILD@%$CFLAGS_FOR_BUILD%g
7426 s%@CC_FOR_TARGET@%$CC_FOR_TARGET%g
7427 s%@CXX_FOR_TARGET@%$CXX_FOR_TARGET%g
7428 s%@GCC_FOR_TARGET@%$GCC_FOR_TARGET%g
7429 s%@GCJ_FOR_TARGET@%$GCJ_FOR_TARGET%g
7430 s%@GFORTRAN_FOR_TARGET@%$GFORTRAN_FOR_TARGET%g
7431 s%@AR_FOR_TARGET@%$AR_FOR_TARGET%g
7432 s%@AS_FOR_TARGET@%$AS_FOR_TARGET%g
7433 s%@DLLTOOL_FOR_TARGET@%$DLLTOOL_FOR_TARGET%g
7434 s%@LD_FOR_TARGET@%$LD_FOR_TARGET%g
7435 s%@LIPO_FOR_TARGET@%$LIPO_FOR_TARGET%g
7436 s%@NM_FOR_TARGET@%$NM_FOR_TARGET%g
7437 s%@OBJDUMP_FOR_TARGET@%$OBJDUMP_FOR_TARGET%g
7438 s%@RANLIB_FOR_TARGET@%$RANLIB_FOR_TARGET%g
7439 s%@STRIP_FOR_TARGET@%$STRIP_FOR_TARGET%g
7440 s%@WINDRES_FOR_TARGET@%$WINDRES_FOR_TARGET%g
7441 s%@FLAGS_FOR_TARGET@%$FLAGS_FOR_TARGET%g
7442 s%@RAW_CXX_FOR_TARGET@%$RAW_CXX_FOR_TARGET%g
7443 s%@COMPILER_AS_FOR_TARGET@%$COMPILER_AS_FOR_TARGET%g
7444 s%@COMPILER_LD_FOR_TARGET@%$COMPILER_LD_FOR_TARGET%g
7445 s%@COMPILER_NM_FOR_TARGET@%$COMPILER_NM_FOR_TARGET%g
7446 s%@MAINTAINER_MODE_TRUE@%$MAINTAINER_MODE_TRUE%g
7447 s%@MAINTAINER_MODE_FALSE@%$MAINTAINER_MODE_FALSE%g
7448 s%@MAINT@%$MAINT%g
7449 s%@stage1_cflags@%$stage1_cflags%g
7450 s%@stage2_werror_flag@%$stage2_werror_flag%g
7451
7452 CEOF
7453 EOF
7454
7455 cat >> $CONFIG_STATUS <<\EOF
7456
7457 # Split the substitutions into bite-sized pieces for seds with
7458 # small command number limits, like on Digital OSF/1 and HP-UX.
7459 ac_max_sed_cmds=90 # Maximum number of lines to put in a sed script.
7460 ac_file=1 # Number of current file.
7461 ac_beg=1 # First line for current file.
7462 ac_end=$ac_max_sed_cmds # Line after last line for current file.
7463 ac_more_lines=:
7464 ac_sed_cmds=""
7465 while $ac_more_lines; do
7466   if test $ac_beg -gt 1; then
7467     sed "1,${ac_beg}d; ${ac_end}q" conftest.subs > conftest.s$ac_file
7468   else
7469     sed "${ac_end}q" conftest.subs > conftest.s$ac_file
7470   fi
7471   if test ! -s conftest.s$ac_file; then
7472     ac_more_lines=false
7473     rm -f conftest.s$ac_file
7474   else
7475     if test -z "$ac_sed_cmds"; then
7476       ac_sed_cmds="sed -f conftest.s$ac_file"
7477     else
7478       ac_sed_cmds="$ac_sed_cmds | sed -f conftest.s$ac_file"
7479     fi
7480     ac_file=`expr $ac_file + 1`
7481     ac_beg=$ac_end
7482     ac_end=`expr $ac_end + $ac_max_sed_cmds`
7483   fi
7484 done
7485 if test -z "$ac_sed_cmds"; then
7486   ac_sed_cmds=cat
7487 fi
7488 EOF
7489
7490 cat >> $CONFIG_STATUS <<EOF
7491
7492 CONFIG_FILES=\${CONFIG_FILES-"Makefile"}
7493 EOF
7494 cat >> $CONFIG_STATUS <<\EOF
7495 for ac_file in .. $CONFIG_FILES; do if test "x$ac_file" != x..; then
7496   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
7497   case "$ac_file" in
7498   *:*) ac_file_in=`echo "$ac_file"|sed 's%[^:]*:%%'`
7499        ac_file=`echo "$ac_file"|sed 's%:.*%%'` ;;
7500   *) ac_file_in="${ac_file}.in" ;;
7501   esac
7502
7503   # Adjust a relative srcdir, top_srcdir, and INSTALL for subdirectories.
7504
7505   # Remove last slash and all that follows it.  Not all systems have dirname.
7506   ac_dir=`echo $ac_file|sed 's%/[^/][^/]*$%%'`
7507   if test "$ac_dir" != "$ac_file" && test "$ac_dir" != .; then
7508     # The file is in a subdirectory.
7509     test ! -d "$ac_dir" && mkdir "$ac_dir"
7510     ac_dir_suffix="/`echo $ac_dir|sed 's%^\./%%'`"
7511     # A "../" for each directory in $ac_dir_suffix.
7512     ac_dots=`echo $ac_dir_suffix|sed 's%/[^/]*%../%g'`
7513   else
7514     ac_dir_suffix= ac_dots=
7515   fi
7516
7517   case "$ac_given_srcdir" in
7518   .)  srcdir=.
7519       if test -z "$ac_dots"; then top_srcdir=.
7520       else top_srcdir=`echo $ac_dots|sed 's%/$%%'`; fi ;;
7521   /*) srcdir="$ac_given_srcdir$ac_dir_suffix"; top_srcdir="$ac_given_srcdir" ;;
7522   *) # Relative path.
7523     srcdir="$ac_dots$ac_given_srcdir$ac_dir_suffix"
7524     top_srcdir="$ac_dots$ac_given_srcdir" ;;
7525   esac
7526
7527   case "$ac_given_INSTALL" in
7528   [/$]*) INSTALL="$ac_given_INSTALL" ;;
7529   *) INSTALL="$ac_dots$ac_given_INSTALL" ;;
7530   esac
7531
7532   echo creating "$ac_file"
7533   rm -f "$ac_file"
7534   configure_input="Generated automatically from `echo $ac_file_in|sed 's%.*/%%'` by configure."
7535   case "$ac_file" in
7536   *Makefile*) ac_comsub="1i\\
7537 # $configure_input" ;;
7538   *) ac_comsub= ;;
7539   esac
7540
7541   ac_file_inputs=`echo $ac_file_in|sed -e "s%^%$ac_given_srcdir/%" -e "s%:% $ac_given_srcdir/%g"`
7542   sed -e "$ac_comsub
7543 s%@configure_input@%$configure_input%g
7544 s%@srcdir@%$srcdir%g
7545 s%@top_srcdir@%$top_srcdir%g
7546 s%@INSTALL@%$INSTALL%g
7547 " $ac_file_inputs | (eval "$ac_sed_cmds") > $ac_file
7548 fi; done
7549 rm -f conftest.s*
7550
7551 EOF
7552 cat >> $CONFIG_STATUS <<EOF
7553
7554 EOF
7555 cat >> $CONFIG_STATUS <<\EOF
7556
7557 exit 0
7558 EOF
7559 chmod +x $CONFIG_STATUS
7560 rm -fr confdefs* $ac_clean_files
7561 test "$no_create" = yes || ${CONFIG_SHELL-/bin/sh} $CONFIG_STATUS || exit 1
7562