configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --enable-stage1-languages[=all]   choose additional languages to build during
 939                           stage1.  Mostly useful for compiler development.
 940   --enable-objc-gc        enable use of Boehm's garbage collector with the
 941                           GNU Objective-C runtime
 942   --enable-bootstrap      enable bootstrapping [yes if native build]
 943   --enable-serial-[{host,target,build}-]configure
 944                           force sequential configuration of
 945                           sub-packages for the host, target or build
 946                           machine, or all sub-packages
 947   --enable-maintainer-mode enable make rules and dependencies not useful
 948                           (and sometimes confusing) to the casual installer
 949   --enable-stage1-checking[=all]   choose additional checking for stage1
 950                           of the compiler
 951   --enable-werror         enable -Werror in bootstrap stage2 and later
 952
 953 Optional Packages:
 954   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 955   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 956   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 957   --with-mpfr-dir=PATH    this option has been REMOVED
 958   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 959                           Equivalent to --with-mpfr-include=PATH/include
 960                           plus --with-mpfr-lib=PATH/lib
 961   --with-mpfr-include=PATH
 962                           specify directory for installed MPFR include files
 963   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 964   --with-gmp-dir=PATH     this option has been REMOVED
 965   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 966                           Equivalent to --with-gmp-include=PATH/include
 967                           plus --with-gmp-lib=PATH/lib
 968   --with-gmp-include=PATH specify directory for installed GMP include files
 969   --with-gmp-lib=PATH     specify directory for the installed GMP library
 970   --with-build-sysroot=SYSROOT
 971                           use sysroot as the system root during the build
 972   --with-debug-prefix-map='A=B C=D ...'
 973                              map A to B, C to D ... in debug information
 974   --with-build-time-tools=PATH
 975                           use given path to find target tools during the build
 976   --with-datarootdir      use datarootdir as the data root directory.
 977   --with-docdir           install documentation in this directory.
 978   --with-pdfdir           install pdf in this directory.
 979   --with-htmldir          install html in this directory.
 980
 981 Some influential environment variables:
 982   CC          C compiler command
 983   CFLAGS      C compiler flags
 984   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 985               nonstandard directory <lib dir>
 986   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 987               headers in a nonstandard directory <include dir>
 988   CXX         C++ compiler command
 989   CXXFLAGS    C++ compiler flags
 990   AR          AR for the host
 991   AS          AS for the host
 992   DLLTOOL     DLLTOOL for the host
 993   LD          LD for the host
 994   LIPO        LIPO for the host
 995   NM          NM for the host
 996   RANLIB      RANLIB for the host
 997   STRIP       STRIP for the host
 998   WINDRES     WINDRES for the host
 999   WINDMC      WINDMC for the host
1000   OBJCOPY     OBJCOPY for the host
1001   OBJDUMP     OBJDUMP for the host
1002   CC_FOR_TARGET
1003               CC for the target
1004   CXX_FOR_TARGET
1005               CXX for the target
1006   GCC_FOR_TARGET
1007               GCC for the target
1008   GCJ_FOR_TARGET
1009               GCJ for the target
1010   GFORTRAN_FOR_TARGET
1011               GFORTRAN for the target
1012   AR_FOR_TARGET
1013               AR for the target
1014   AS_FOR_TARGET
1015               AS for the target
1016   DLLTOOL_FOR_TARGET
1017               DLLTOOL for the target
1018   LD_FOR_TARGET
1019               LD for the target
1020   LIPO_FOR_TARGET
1021               LIPO for the target
1022   NM_FOR_TARGET
1023               NM for the target
1024   OBJDUMP_FOR_TARGET
1025               OBJDUMP for the target
1026   RANLIB_FOR_TARGET
1027               RANLIB for the target
1028   STRIP_FOR_TARGET
1029               STRIP for the target
1030   WINDRES_FOR_TARGET
1031               WINDRES for the target
1032   WINDMC_FOR_TARGET
1033               WINDMC for the target
1034
1035 Use these variables to override the choices made by `configure' or to help
1036 it to find libraries and programs with nonstandard names/locations.
1037
1038 _ACEOF
1039 fi
1040
1041 if test "$ac_init_help" = "recursive"; then
1042   # If there are subdirs, report their specific --help.
1043   ac_popdir=`pwd`
1044   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1045     test -d $ac_dir || continue
1046     ac_builddir=.
1047
1048 if test "$ac_dir" != .; then
1049   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1050   # A "../" for each directory in $ac_dir_suffix.
1051   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1052 else
1053   ac_dir_suffix= ac_top_builddir=
1054 fi
1055
1056 case $srcdir in
1057   .)  # No --srcdir option.  We are building in place.
1058     ac_srcdir=.
1059     if test -z "$ac_top_builddir"; then
1060        ac_top_srcdir=.
1061     else
1062        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1063     fi ;;
1064   [\\/]* | ?:[\\/]* )  # Absolute path.
1065     ac_srcdir=$srcdir$ac_dir_suffix;
1066     ac_top_srcdir=$srcdir ;;
1067   *) # Relative path.
1068     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1069     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1070 esac
1071
1072 # Do not use `cd foo && pwd` to compute absolute paths, because
1073 # the directories may not exist.
1074 case `pwd` in
1075 .) ac_abs_builddir="$ac_dir";;
1076 *)
1077   case "$ac_dir" in
1078   .) ac_abs_builddir=`pwd`;;
1079   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1080   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1081   esac;;
1082 esac
1083 case $ac_abs_builddir in
1084 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1085 *)
1086   case ${ac_top_builddir}. in
1087   .) ac_abs_top_builddir=$ac_abs_builddir;;
1088   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1089   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1090   esac;;
1091 esac
1092 case $ac_abs_builddir in
1093 .) ac_abs_srcdir=$ac_srcdir;;
1094 *)
1095   case $ac_srcdir in
1096   .) ac_abs_srcdir=$ac_abs_builddir;;
1097   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1098   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1099   esac;;
1100 esac
1101 case $ac_abs_builddir in
1102 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1103 *)
1104   case $ac_top_srcdir in
1105   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1106   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1107   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1108   esac;;
1109 esac
1110
1111     cd $ac_dir
1112     # Check for guested configure; otherwise get Cygnus style configure.
1113     if test -f $ac_srcdir/configure.gnu; then
1114       echo
1115       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1116     elif test -f $ac_srcdir/configure; then
1117       echo
1118       $SHELL $ac_srcdir/configure  --help=recursive
1119     elif test -f $ac_srcdir/configure.ac ||
1120            test -f $ac_srcdir/configure.in; then
1121       echo
1122       $ac_configure --help
1123     else
1124       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1125     fi
1126     cd $ac_popdir
1127   done
1128 fi
1129
1130 test -n "$ac_init_help" && exit 0
1131 if $ac_init_version; then
1132   cat <<\_ACEOF
1133
1134 Copyright (C) 2003 Free Software Foundation, Inc.
1135 This configure script is free software; the Free Software Foundation
1136 gives unlimited permission to copy, distribute and modify it.
1137 _ACEOF
1138   exit 0
1139 fi
1140 exec 5>config.log
1141 cat >&5 <<_ACEOF
1142 This file contains any messages produced by compilers while
1143 running configure, to aid debugging if configure makes a mistake.
1144
1145 It was created by $as_me, which was
1146 generated by GNU Autoconf 2.59.  Invocation command line was
1147
1148   $ $0 $@
1149
1150 _ACEOF
1151 {
1152 cat <<_ASUNAME
1153 ## --------- ##
1154 ## Platform. ##
1155 ## --------- ##
1156
1157 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1158 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1159 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1160 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1161 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1162
1163 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1164 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1165
1166 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1167 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1168 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1169 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1170 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1171 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1172 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1173
1174 _ASUNAME
1175
1176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1177 for as_dir in $PATH
1178 do
1179   IFS=$as_save_IFS
1180   test -z "$as_dir" && as_dir=.
1181   echo "PATH: $as_dir"
1182 done
1183
1184 } >&5
1185
1186 cat >&5 <<_ACEOF
1187
1188
1189 ## ----------- ##
1190 ## Core tests. ##
1191 ## ----------- ##
1192
1193 _ACEOF
1194
1195
1196 # Keep a trace of the command line.
1197 # Strip out --no-create and --no-recursion so they do not pile up.
1198 # Strip out --silent because we don't want to record it for future runs.
1199 # Also quote any args containing shell meta-characters.
1200 # Make two passes to allow for proper duplicate-argument suppression.
1201 ac_configure_args=
1202 ac_configure_args0=
1203 ac_configure_args1=
1204 ac_sep=
1205 ac_must_keep_next=false
1206 for ac_pass in 1 2
1207 do
1208   for ac_arg
1209   do
1210     case $ac_arg in
1211     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1212     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1213     | -silent | --silent | --silen | --sile | --sil)
1214       continue ;;
1215     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1216       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1217     esac
1218     case $ac_pass in
1219     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1220     2)
1221       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1222       if test $ac_must_keep_next = true; then
1223         ac_must_keep_next=false # Got value, back to normal.
1224       else
1225         case $ac_arg in
1226           *=* | --config-cache | -C | -disable-* | --disable-* \
1227           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1228           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1229           | -with-* | --with-* | -without-* | --without-* | --x)
1230             case "$ac_configure_args0 " in
1231               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1232             esac
1233             ;;
1234           -* ) ac_must_keep_next=true ;;
1235         esac
1236       fi
1237       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1238       # Get rid of the leading space.
1239       ac_sep=" "
1240       ;;
1241     esac
1242   done
1243 done
1244 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1245 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1246
1247 # When interrupted or exit'd, cleanup temporary files, and complete
1248 # config.log.  We remove comments because anyway the quotes in there
1249 # would cause problems or look ugly.
1250 # WARNING: Be sure not to use single quotes in there, as some shells,
1251 # such as our DU 5.0 friend, will then `close' the trap.
1252 trap 'exit_status=$?
1253   # Save into config.log some information that might help in debugging.
1254   {
1255     echo
1256
1257     cat <<\_ASBOX
1258 ## ---------------- ##
1259 ## Cache variables. ##
1260 ## ---------------- ##
1261 _ASBOX
1262     echo
1263     # The following way of writing the cache mishandles newlines in values,
1264 {
1265   (set) 2>&1 |
1266     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1267     *ac_space=\ *)
1268       sed -n \
1269         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1270           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1271       ;;
1272     *)
1273       sed -n \
1274         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1275       ;;
1276     esac;
1277 }
1278     echo
1279
1280     cat <<\_ASBOX
1281 ## ----------------- ##
1282 ## Output variables. ##
1283 ## ----------------- ##
1284 _ASBOX
1285     echo
1286     for ac_var in $ac_subst_vars
1287     do
1288       eval ac_val=$`echo $ac_var`
1289       echo "$ac_var='"'"'$ac_val'"'"'"
1290     done | sort
1291     echo
1292
1293     if test -n "$ac_subst_files"; then
1294       cat <<\_ASBOX
1295 ## ------------- ##
1296 ## Output files. ##
1297 ## ------------- ##
1298 _ASBOX
1299       echo
1300       for ac_var in $ac_subst_files
1301       do
1302         eval ac_val=$`echo $ac_var`
1303         echo "$ac_var='"'"'$ac_val'"'"'"
1304       done | sort
1305       echo
1306     fi
1307
1308     if test -s confdefs.h; then
1309       cat <<\_ASBOX
1310 ## ----------- ##
1311 ## confdefs.h. ##
1312 ## ----------- ##
1313 _ASBOX
1314       echo
1315       sed "/^$/d" confdefs.h | sort
1316       echo
1317     fi
1318     test "$ac_signal" != 0 &&
1319       echo "$as_me: caught signal $ac_signal"
1320     echo "$as_me: exit $exit_status"
1321   } >&5
1322   rm -f core *.core &&
1323   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1324     exit $exit_status
1325      ' 0
1326 for ac_signal in 1 2 13 15; do
1327   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1328 done
1329 ac_signal=0
1330
1331 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1332 rm -rf conftest* confdefs.h
1333 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1334 echo >confdefs.h
1335
1336 # Predefined preprocessor variables.
1337
1338 cat >>confdefs.h <<_ACEOF
1339 #define PACKAGE_NAME "$PACKAGE_NAME"
1340 _ACEOF
1341
1342
1343 cat >>confdefs.h <<_ACEOF
1344 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1345 _ACEOF
1346
1347
1348 cat >>confdefs.h <<_ACEOF
1349 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1350 _ACEOF
1351
1352
1353 cat >>confdefs.h <<_ACEOF
1354 #define PACKAGE_STRING "$PACKAGE_STRING"
1355 _ACEOF
1356
1357
1358 cat >>confdefs.h <<_ACEOF
1359 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1360 _ACEOF
1361
1362
1363 # Let the site file select an alternate cache file if it wants to.
1364 # Prefer explicitly selected file to automatically selected ones.
1365 if test -z "$CONFIG_SITE"; then
1366   if test "x$prefix" != xNONE; then
1367     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1368   else
1369     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1370   fi
1371 fi
1372 for ac_site_file in $CONFIG_SITE; do
1373   if test -r "$ac_site_file"; then
1374     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1375 echo "$as_me: loading site script $ac_site_file" >&6;}
1376     sed 's/^/| /' "$ac_site_file" >&5
1377     . "$ac_site_file"
1378   fi
1379 done
1380
1381 if test -r "$cache_file"; then
1382   # Some versions of bash will fail to source /dev/null (special
1383   # files actually), so we avoid doing that.
1384   if test -f "$cache_file"; then
1385     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1386 echo "$as_me: loading cache $cache_file" >&6;}
1387     case $cache_file in
1388       [\\/]* | ?:[\\/]* ) . $cache_file;;
1389       *)                      . ./$cache_file;;
1390     esac
1391   fi
1392 else
1393   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1394 echo "$as_me: creating cache $cache_file" >&6;}
1395   >$cache_file
1396 fi
1397
1398 # Check that the precious variables saved in the cache have kept the same
1399 # value.
1400 ac_cache_corrupted=false
1401 for ac_var in `(set) 2>&1 |
1402                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1403   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1404   eval ac_new_set=\$ac_env_${ac_var}_set
1405   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1406   eval ac_new_val="\$ac_env_${ac_var}_value"
1407   case $ac_old_set,$ac_new_set in
1408     set,)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,set)
1413       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1414 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1415       ac_cache_corrupted=: ;;
1416     ,);;
1417     *)
1418       if test "x$ac_old_val" != "x$ac_new_val"; then
1419         # differences in whitespace do not lead to failure.
1420         ac_old_val_w=`echo x $ac_old_val`
1421         ac_new_val_w=`echo x $ac_new_val`
1422         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1423           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1424 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1425           ac_cache_corrupted=:
1426         else
1427           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1428 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1429           eval $ac_var=\$ac_old_val
1430         fi
1431         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1432 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1433         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1434 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1435       fi;;
1436   esac
1437   # Pass precious variables to config.status.
1438   if test "$ac_new_set" = set; then
1439     case $ac_new_val in
1440     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1441       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1442     *) ac_arg=$ac_var=$ac_new_val ;;
1443     esac
1444     case " $ac_configure_args " in
1445       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1446       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1447     esac
1448   fi
1449 done
1450 if $ac_cache_corrupted; then
1451   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1452 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1453   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1454 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1455   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1456 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1457    { (exit 1); exit 1; }; }
1458 fi
1459
1460 ac_ext=c
1461 ac_cpp='$CPP $CPPFLAGS'
1462 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1463 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1464 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489 progname=$0
1490 # if PWD already has a value, it is probably wrong.
1491 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1492
1493 # Export original configure arguments for use by sub-configures.
1494 # Quote arguments with shell meta charatcers.
1495 TOPLEVEL_CONFIGURE_ARGUMENTS=
1496 set -- "$progname" "$@"
1497 for ac_arg
1498 do
1499   case "$ac_arg" in
1500   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1501     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1502     # if the argument is of the form -foo=baz, quote the baz part only
1503     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1504   *) ;;
1505   esac
1506   # Add the quoted argument to the list.
1507   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1508 done
1509 if test "$silent" = yes; then
1510   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1511 fi
1512 # Remove the initial space we just introduced and, as these will be
1513 # expanded by make, quote '$'.
1514 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1515
1516
1517 # Find the build, host, and target systems.
1518 ac_aux_dir=
1519 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1520   if test -f $ac_dir/install-sh; then
1521     ac_aux_dir=$ac_dir
1522     ac_install_sh="$ac_aux_dir/install-sh -c"
1523     break
1524   elif test -f $ac_dir/install.sh; then
1525     ac_aux_dir=$ac_dir
1526     ac_install_sh="$ac_aux_dir/install.sh -c"
1527     break
1528   elif test -f $ac_dir/shtool; then
1529     ac_aux_dir=$ac_dir
1530     ac_install_sh="$ac_aux_dir/shtool install -c"
1531     break
1532   fi
1533 done
1534 if test -z "$ac_aux_dir"; then
1535   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1536 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1537    { (exit 1); exit 1; }; }
1538 fi
1539 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1540 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1541 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1542
1543 # Make sure we can run config.sub.
1544 $ac_config_sub sun4 >/dev/null 2>&1 ||
1545   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1546 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1547    { (exit 1); exit 1; }; }
1548
1549 echo "$as_me:$LINENO: checking build system type" >&5
1550 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1551 if test "${ac_cv_build+set}" = set; then
1552   echo $ECHO_N "(cached) $ECHO_C" >&6
1553 else
1554   ac_cv_build_alias=$build_alias
1555 test -z "$ac_cv_build_alias" &&
1556   ac_cv_build_alias=`$ac_config_guess`
1557 test -z "$ac_cv_build_alias" &&
1558   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1559 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1560    { (exit 1); exit 1; }; }
1561 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1562   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1563 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1564    { (exit 1); exit 1; }; }
1565
1566 fi
1567 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1568 echo "${ECHO_T}$ac_cv_build" >&6
1569 build=$ac_cv_build
1570 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1571 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1572 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1573
1574
1575  case ${build_alias} in
1576   "") build_noncanonical=${build} ;;
1577   *) build_noncanonical=${build_alias} ;;
1578 esac
1579
1580
1581
1582  case ${host_alias} in
1583   "") host_noncanonical=${build_noncanonical} ;;
1584   *) host_noncanonical=${host_alias} ;;
1585 esac
1586
1587
1588
1589  case ${target_alias} in
1590   "") target_noncanonical=${host_noncanonical} ;;
1591   *) target_noncanonical=${target_alias} ;;
1592 esac
1593
1594
1595
1596
1597 test "$host_noncanonical" = "$target_noncanonical" &&
1598   test "$program_prefix$program_suffix$program_transform_name" = \
1599     NONENONEs,x,x, &&
1600   program_transform_name=s,y,y,
1601
1602 echo "$as_me:$LINENO: checking host system type" >&5
1603 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1604 if test "${ac_cv_host+set}" = set; then
1605   echo $ECHO_N "(cached) $ECHO_C" >&6
1606 else
1607   ac_cv_host_alias=$host_alias
1608 test -z "$ac_cv_host_alias" &&
1609   ac_cv_host_alias=$ac_cv_build_alias
1610 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1611   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1612 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1613    { (exit 1); exit 1; }; }
1614
1615 fi
1616 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1617 echo "${ECHO_T}$ac_cv_host" >&6
1618 host=$ac_cv_host
1619 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1620 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1621 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1622
1623
1624 echo "$as_me:$LINENO: checking target system type" >&5
1625 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1626 if test "${ac_cv_target+set}" = set; then
1627   echo $ECHO_N "(cached) $ECHO_C" >&6
1628 else
1629   ac_cv_target_alias=$target_alias
1630 test "x$ac_cv_target_alias" = "x" &&
1631   ac_cv_target_alias=$ac_cv_host_alias
1632 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1633   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1634 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1635    { (exit 1); exit 1; }; }
1636
1637 fi
1638 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1639 echo "${ECHO_T}$ac_cv_target" >&6
1640 target=$ac_cv_target
1641 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1642 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1643 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1644
1645
1646 # The aliases save the names the user supplied, while $host etc.
1647 # will get canonicalized.
1648 test -n "$target_alias" &&
1649   test "$program_prefix$program_suffix$program_transform_name" = \
1650     NONENONEs,x,x, &&
1651   program_prefix=${target_alias}-
1652 test "$program_prefix" != NONE &&
1653   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1654 # Use a double $ so make ignores it.
1655 test "$program_suffix" != NONE &&
1656   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1657 # Double any \ or $.  echo might interpret backslashes.
1658 # By default was `s,x,x', remove it if useless.
1659 cat <<\_ACEOF >conftest.sed
1660 s/[\\$]/&&/g;s/;s,x,x,$//
1661 _ACEOF
1662 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1663 rm conftest.sed
1664
1665
1666
1667 # Get 'install' or 'install-sh' and its variants.
1668 # Find a good install program.  We prefer a C program (faster),
1669 # so one script is as good as another.  But avoid the broken or
1670 # incompatible versions:
1671 # SysV /etc/install, /usr/sbin/install
1672 # SunOS /usr/etc/install
1673 # IRIX /sbin/install
1674 # AIX /bin/install
1675 # AmigaOS /C/install, which installs bootblocks on floppy discs
1676 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1677 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1678 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1679 # OS/2's system install, which has a completely different semantic
1680 # ./install, which can be erroneously created by make from ./install.sh.
1681 # Reject install programs that cannot install multiple files.
1682 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1683 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1684 if test -z "$INSTALL"; then
1685 if test "${ac_cv_path_install+set}" = set; then
1686   echo $ECHO_N "(cached) $ECHO_C" >&6
1687 else
1688   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1689 for as_dir in $PATH
1690 do
1691   IFS=$as_save_IFS
1692   test -z "$as_dir" && as_dir=.
1693   # Account for people who put trailing slashes in PATH elements.
1694 case $as_dir/ in
1695   ./ | .// | /cC/* | \
1696   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1697   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1698   /usr/ucb/* ) ;;
1699   *)
1700     # OSF1 and SCO ODT 3.0 have their own names for install.
1701     # Don't use installbsd from OSF since it installs stuff as root
1702     # by default.
1703     for ac_prog in ginstall scoinst install; do
1704       for ac_exec_ext in '' $ac_executable_extensions; do
1705         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1706           if test $ac_prog = install &&
1707             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1708             # AIX install.  It has an incompatible calling convention.
1709             :
1710           elif test $ac_prog = install &&
1711             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1712             # program-specific install script used by HP pwplus--don't use.
1713             :
1714           else
1715             rm -rf conftest.one conftest.two conftest.dir
1716             echo one > conftest.one
1717             echo two > conftest.two
1718             mkdir conftest.dir
1719             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1720               test -s conftest.one && test -s conftest.two &&
1721               test -s conftest.dir/conftest.one &&
1722               test -s conftest.dir/conftest.two
1723             then
1724               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1725               break 3
1726             fi
1727           fi
1728         fi
1729       done
1730     done
1731     ;;
1732 esac
1733 done
1734
1735 rm -rf conftest.one conftest.two conftest.dir
1736
1737 fi
1738   if test "${ac_cv_path_install+set}" = set; then
1739     INSTALL=$ac_cv_path_install
1740   else
1741     # As a last resort, use the slow shell script.  Don't cache a
1742     # value for INSTALL within a source directory, because that will
1743     # break other packages using the cache if that directory is
1744     # removed, or if the value is a relative name.
1745     INSTALL=$ac_install_sh
1746   fi
1747 fi
1748 echo "$as_me:$LINENO: result: $INSTALL" >&5
1749 echo "${ECHO_T}$INSTALL" >&6
1750
1751 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1752 # It thinks the first close brace ends the variable substitution.
1753 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1754
1755 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1756
1757 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1758
1759 echo "$as_me:$LINENO: checking whether ln works" >&5
1760 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1761 if test "${acx_cv_prog_LN+set}" = set; then
1762   echo $ECHO_N "(cached) $ECHO_C" >&6
1763 else
1764   rm -f conftestdata_t
1765 echo >conftestdata_f
1766 if ln conftestdata_f conftestdata_t 2>/dev/null
1767 then
1768   acx_cv_prog_LN=ln
1769 else
1770   acx_cv_prog_LN=no
1771 fi
1772 rm -f conftestdata_f conftestdata_t
1773
1774 fi
1775 if test $acx_cv_prog_LN = no; then
1776   LN="cp"
1777   echo "$as_me:$LINENO: result: no, using $LN" >&5
1778 echo "${ECHO_T}no, using $LN" >&6
1779 else
1780   LN="$acx_cv_prog_LN"
1781   echo "$as_me:$LINENO: result: yes" >&5
1782 echo "${ECHO_T}yes" >&6
1783 fi
1784
1785 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1786 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1787 LN_S=$as_ln_s
1788 if test "$LN_S" = "ln -s"; then
1789   echo "$as_me:$LINENO: result: yes" >&5
1790 echo "${ECHO_T}yes" >&6
1791 else
1792   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1793 echo "${ECHO_T}no, using $LN_S" >&6
1794 fi
1795
1796
1797 ### we might need to use some other shell than /bin/sh for running subshells
1798 ### If we are on Windows, search for the shell.  This will permit people
1799 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1800 ### without also having to set CONFIG_SHELL.  This code will work when
1801 ### using bash, which sets OSTYPE.
1802 case "${OSTYPE}" in
1803 *win32*)
1804   if test x${CONFIG_SHELL} = x ; then
1805     if test ! -f /bin/sh ; then
1806       if test x${SHELL} != x && test -f ${SHELL} ; then
1807         CONFIG_SHELL=${SHELL}
1808         export CONFIG_SHELL
1809       else
1810         for prog in sh sh.exe bash bash.exe; do
1811           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1812           for dir in $PATH; do
1813             test -z "$dir" && dir=.
1814             if test -f $dir/$prog; then
1815               CONFIG_SHELL=$dir/$prog
1816               export CONFIG_SHELL
1817               break
1818             fi
1819           done
1820           IFS="$save_ifs"
1821           test -n "${CONFIG_SHELL}" && break
1822         done
1823       fi
1824     fi
1825   fi
1826   ;;
1827 esac
1828
1829 config_shell=${CONFIG_SHELL-/bin/sh}
1830
1831 moveifchange=${srcdir}/move-if-change
1832
1833 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1834
1835 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1836 # a relative path.
1837 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1838   INSTALL="${srcpwd}/install-sh -c"
1839 fi
1840
1841 # Set srcdir to "." if that's what it is.
1842 # This is important for multilib support.
1843 pwd=`${PWDCMD-pwd}`
1844 if test "${pwd}" = "${srcpwd}" ; then
1845   srcdir=.
1846 fi
1847
1848 topsrcdir=$srcpwd
1849
1850 extra_host_args=
1851
1852 ### To add a new directory to the tree, first choose whether it is a target
1853 ### or a host dependent tool.  Then put it into the appropriate list
1854 ### (library or tools, host or target), doing a dependency sort.
1855
1856 # Subdirs will be configured in the order listed in build_configdirs,
1857 # configdirs, or target_configdirs; see the serialization section below.
1858
1859 # Dependency sorting is only needed when *configuration* must be done in
1860 # a particular order.  In all cases a dependency should be specified in
1861 # the Makefile, whether or not it's implicitly specified here.
1862
1863 # Double entries in build_configdirs, configdirs, or target_configdirs may
1864 # cause circular dependencies and break everything horribly.
1865
1866 # these library is used by various programs built for the build
1867 # environment
1868 #
1869 build_libs="build-libiberty"
1870
1871 # these tools are built for the build environment
1872 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1873
1874 # these libraries are used by various programs built for the host environment
1875 #
1876 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1877
1878 # these tools are built for the host environment
1879 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1880 # know that we are building the simulator.
1881 # binutils, gas and ld appear in that order because it makes sense to run
1882 # "make check" in that particular order.
1883 # If --enable-gold is used, "gold" will replace "ld".
1884 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"
1885
1886 # libgcj represents the runtime libraries only used by gcj.
1887 libgcj="target-libffi \
1888         target-zlib \
1889         target-qthreads \
1890         target-libjava"
1891
1892 # these libraries are built for the target environment, and are built after
1893 # the host libraries and the host tools (which may be a cross compiler)
1894 #
1895 target_libraries="target-libgcc \
1896                 target-libiberty \
1897                 target-libgloss \
1898                 target-newlib \
1899                 target-libgomp \
1900                 target-libstdc++-v3 \
1901                 target-libmudflap \
1902                 target-libssp \
1903                 target-libgfortran \
1904                 target-boehm-gc \
1905                 ${libgcj} \
1906                 target-libobjc \
1907                 target-libada"
1908
1909 # these tools are built using the target libraries, and are intended to
1910 # run only in the target environment
1911 #
1912 # note: any program that *uses* libraries that are in the "target_libraries"
1913 # list belongs in this list.  those programs are also very likely
1914 # candidates for the "native_only" list which follows
1915 #
1916 target_tools="target-examples target-groff target-gperf target-rda"
1917
1918 ################################################################################
1919
1920 ## All tools belong in one of the four categories, and are assigned above
1921 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1922 ## is important because configure will choke if they ever get through.
1923 ## ${configdirs} is directories we build using the host tools.
1924 ## ${target_configdirs} is directories we build using the target tools.
1925 configdirs=`echo ${host_libs} ${host_tools}`
1926 target_configdirs=`echo ${target_libraries} ${target_tools}`
1927 build_configdirs=`echo ${build_libs} ${build_tools}`
1928
1929
1930
1931 ################################################################################
1932
1933 srcname="gnu development package"
1934
1935 # This gets set non-empty for some net releases of packages.
1936 appdirs=""
1937
1938 # Define is_cross_compiler to save on calls to 'test'.
1939 is_cross_compiler=
1940 if test x"${host}" = x"${target}" ; then
1941   is_cross_compiler=no
1942 else
1943   is_cross_compiler=yes
1944 fi
1945
1946 # Find the build and target subdir names.
1947
1948 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1949 # have matching libraries, they should use host libraries: Makefile.tpl
1950 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1951 # However, they still use the build modules, because the corresponding
1952 # host modules (e.g. bison) are only built for the host when bootstrap
1953 # finishes. So:
1954 # - build_subdir is where we find build modules, and never changes.
1955 # - build_libsubdir is where we find build libraries, and can be overridden.
1956
1957 # Prefix 'build-' so this never conflicts with target_subdir.
1958 build_subdir="build-${build_noncanonical}"
1959
1960 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1961 if test "${with_build_libsubdir+set}" = set; then
1962   withval="$with_build_libsubdir"
1963   build_libsubdir="$withval"
1964 else
1965   build_libsubdir="$build_subdir"
1966 fi;
1967 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1968 if ( test $srcdir = . && test -d gcc ) \
1969    || test -d $srcdir/../host-${host_noncanonical}; then
1970   host_subdir="host-${host_noncanonical}"
1971 else
1972   host_subdir=.
1973 fi
1974 # No prefix.
1975 target_subdir=${target_noncanonical}
1976
1977
1978 # Skipdirs are removed silently.
1979 skipdirs=
1980 # Noconfigdirs are removed loudly.
1981 noconfigdirs=""
1982
1983 use_gnu_ld=
1984 # Make sure we don't let GNU ld be added if we didn't want it.
1985 if test x$with_gnu_ld = xno ; then
1986   use_gnu_ld=no
1987   noconfigdirs="$noconfigdirs ld gold"
1988 fi
1989
1990 use_gnu_as=
1991 # Make sure we don't let GNU as be added if we didn't want it.
1992 if test x$with_gnu_as = xno ; then
1993   use_gnu_as=no
1994   noconfigdirs="$noconfigdirs gas"
1995 fi
1996
1997 # some tools are so dependent upon X11 that if we're not building with X,
1998 # it's not even worth trying to configure, much less build, that tool.
1999
2000 case ${with_x} in
2001   yes | "") ;; # the default value for this tree is that X11 is available
2002   no)
2003     skipdirs="${skipdirs} tk itcl libgui"
2004     # We won't be able to build gdbtk without X.
2005     enable_gdbtk=no
2006     ;;
2007   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2008 esac
2009
2010 # Some tools are only suitable for building in a "native" situation.
2011 # Remove these if host!=target.
2012 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2013
2014 # Similarly, some are only suitable for cross toolchains.
2015 # Remove these if host=target.
2016 cross_only="target-libgloss target-newlib target-opcodes"
2017
2018 case $is_cross_compiler in
2019   no) skipdirs="${skipdirs} ${cross_only}" ;;
2020   yes) skipdirs="${skipdirs} ${native_only}" ;;
2021 esac
2022
2023 # If both --with-headers and --with-libs are specified, default to
2024 # --without-newlib.
2025 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2026    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2027   if test x"${with_newlib}" = x ; then
2028     with_newlib=no
2029   fi
2030 fi
2031
2032 # Recognize --with-newlib/--without-newlib.
2033 case ${with_newlib} in
2034   no) skipdirs="${skipdirs} target-newlib" ;;
2035   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2036 esac
2037
2038 # Handle --enable-gold.
2039
2040 # Check whether --enable-gold or --disable-gold was given.
2041 if test "${enable_gold+set}" = set; then
2042   enableval="$enable_gold"
2043   ENABLE_GOLD=$enableval
2044 else
2045   ENABLE_GOLD=no
2046 fi;
2047 if test "${ENABLE_GOLD}" = "yes"; then
2048   # Check for ELF target.
2049   is_elf=no
2050   case "${target}" in
2051     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2052     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2053     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2054       case "${target}" in
2055         *-*-linux*aout* | *-*-linux*oldld*)
2056           ;;
2057         *)
2058           is_elf=yes
2059           ;;
2060       esac
2061   esac
2062
2063   if test "$is_elf" = "yes"; then
2064     # Check for target supported by gold.
2065     case "${target}" in
2066       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2067         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2068         ;;
2069     esac
2070   fi
2071 fi
2072
2073 # Configure extra directories which are host specific
2074
2075 case "${host}" in
2076   *-cygwin*)
2077     configdirs="$configdirs libtermcap" ;;
2078 esac
2079
2080 # A target can indicate whether a language isn't supported for some reason.
2081 # Only spaces may be used in this macro; not newlines or tabs.
2082 unsupported_languages=
2083
2084 # Remove more programs from consideration, based on the host or
2085 # target this usually means that a port of the program doesn't
2086 # exist yet.
2087
2088 case "${host}" in
2089   hppa*64*-*-*)
2090     noconfigdirs="$noconfigdirs byacc"
2091     ;;
2092   i[3456789]86-*-vsta)
2093     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2094     ;;
2095   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2096     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2097     ;;
2098   x86_64-*-mingw*)
2099     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2100     ;;
2101   i[3456789]86-*-mingw32*)
2102     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2103     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2104     ;;
2105   i[3456789]86-*-beos*)
2106     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2107     ;;
2108   *-*-cygwin*)
2109     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2110     ;;
2111   *-*-netbsd*)
2112     noconfigdirs="$noconfigdirs rcs"
2113     ;;
2114   ppc*-*-pe)
2115     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2116     ;;
2117   powerpc-*-beos*)
2118     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2119     ;;
2120 esac
2121
2122
2123 # Check whether --enable-libada or --disable-libada was given.
2124 if test "${enable_libada+set}" = set; then
2125   enableval="$enable_libada"
2126   ENABLE_LIBADA=$enableval
2127 else
2128   ENABLE_LIBADA=yes
2129 fi;
2130 if test "${ENABLE_LIBADA}" != "yes" ; then
2131   noconfigdirs="$noconfigdirs gnattools"
2132 fi
2133
2134 # Check whether --enable-libssp or --disable-libssp was given.
2135 if test "${enable_libssp+set}" = set; then
2136   enableval="$enable_libssp"
2137   ENABLE_LIBSSP=$enableval
2138 else
2139   ENABLE_LIBSSP=yes
2140 fi;
2141
2142 # Save it here so that, even in case of --enable-libgcj, if the Java
2143 # front-end isn't enabled, we still get libgcj disabled.
2144 libgcj_saved=$libgcj
2145 case $enable_libgcj in
2146 yes)
2147   # If we reset it here, it won't get added to noconfigdirs in the
2148   # target-specific build rules, so it will be forcibly enabled
2149   # (unless the Java language itself isn't enabled).
2150   libgcj=
2151   ;;
2152 no)
2153   # Make sure we get it printed in the list of not supported target libs.
2154   noconfigdirs="$noconfigdirs ${libgcj}"
2155   ;;
2156 esac
2157
2158
2159 # Disable libmudflap on some systems.
2160 if test x$enable_libmudflap = x ; then
2161     case "${target}" in
2162     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2163         # Enable libmudflap by default in GNU and friends.
2164         ;;
2165     *-*-freebsd*)
2166         # Enable libmudflap by default in FreeBSD.
2167         ;;
2168     *)
2169         # Disable it by default everywhere else.
2170         noconfigdirs="$noconfigdirs target-libmudflap"
2171         ;;
2172     esac
2173 fi
2174
2175 # Disable libgomp on non POSIX hosted systems.
2176 if test x$enable_libgomp = x ; then
2177     # Enable libgomp by default on hosted POSIX systems.
2178     case "${target}" in
2179     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2180         ;;
2181     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2182         ;;
2183     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2184         ;;
2185     *-*-darwin* | *-*-aix*)
2186         ;;
2187     *)
2188         noconfigdirs="$noconfigdirs target-libgomp"
2189         ;;
2190     esac
2191 fi
2192
2193 # Default libgloss CPU subdirectory.
2194 libgloss_dir="$target_cpu"
2195
2196 case "${target}" in
2197   *-*-chorusos)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2199     ;;
2200   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2201     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2202     noconfigdirs="$noconfigdirs sim target-rda"
2203     ;;
2204   *-*-darwin*)
2205     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2206     noconfigdirs="$noconfigdirs sim target-rda"
2207     noconfigdirs="$noconfigdirs ${libgcj}"
2208     ;;
2209   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2210     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2211     ;;
2212   *-*-freebsd*)
2213     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2214     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2215         && test -f /usr/local/include/gmp.h; then
2216       with_gmp=/usr/local
2217     fi
2218
2219     # Skip some stuff that's unsupported on some FreeBSD configurations.
2220     case "${target}" in
2221       i*86-*-*) ;;
2222       alpha*-*-*) ;;
2223       *)
2224         noconfigdirs="$noconfigdirs ${libgcj}"
2225         ;;
2226     esac
2227     ;;
2228   *-*-kaos*)
2229     # Remove unsupported stuff on all kaOS configurations.
2230     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2231     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2232     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2233     noconfigdirs="$noconfigdirs target-libgloss"
2234     ;;
2235   *-*-netbsd*)
2236     # Skip some stuff on all NetBSD configurations.
2237     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2238
2239     # Skip some stuff that's unsupported on some NetBSD configurations.
2240     case "${target}" in
2241       i*86-*-netbsdelf*) ;;
2242       arm*-*-netbsdelf*) ;;
2243       *)
2244         noconfigdirs="$noconfigdirs ${libgcj}"
2245         ;;
2246     esac
2247     ;;
2248   *-*-netware*)
2249     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2250     ;;
2251   *-*-rtems*)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254     # The tpf target doesn't support gdb yet.
2255   *-*-tpf*)
2256     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2257     ;;
2258   *-*-uclinux*)
2259     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2260     ;;
2261   *-*-vxworks*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2263     ;;
2264   alpha*-dec-osf*)
2265     # ld works, but does not support shared libraries.
2266     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2267     # gas doesn't generate exception information.
2268     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2269     ;;
2270   alpha*-*-*vms*)
2271     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2272     ;;
2273   alpha*-*-linux*)
2274     # newlib is not 64 bit ready
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2276     ;;
2277   alpha*-*-*)
2278     # newlib is not 64 bit ready
2279     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2280     ;;
2281   am33_2.0-*-linux*)
2282     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2283     ;;
2284   sh-*-linux*)
2285     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2286     ;;
2287   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2288     noconfigdirs="$noconfigdirs ${libgcj}"
2289     noconfigdirs="$noconfigdirs target-examples"
2290     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2291     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2292     noconfigdirs="$noconfigdirs expect dejagnu"
2293     # the C++ libraries don't build on top of CE's C libraries
2294     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2295     noconfigdirs="$noconfigdirs target-newlib"
2296     case "${host}" in
2297       *-*-cygwin*) ;; # keep gdb and readline
2298       *) noconfigdirs="$noconfigdirs gdb readline"
2299          ;;
2300     esac
2301     libgloss_dir=wince
2302     ;;
2303   arc-*-*)
2304     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2305     ;;
2306   arm-semi-aof )
2307     ;;
2308   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2309     noconfigdirs="$noconfigdirs ${libgcj}"
2310     libgloss_dir=arm
2311     ;;
2312   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2313     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2314     libgloss_dir=arm
2315     ;;
2316   arm*-*-linux-gnueabi)
2317     noconfigdirs="$noconfigdirs target-qthreads"
2318     case ${with_newlib} in
2319       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2320     esac
2321     libgloss_dir=arm
2322     ;;
2323   arm*-*-symbianelf*)
2324     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2325     libgloss_dir=arm
2326     ;;
2327   arm-*-pe*)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   thumb-*-coff)
2331     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2332     ;;
2333   thumb-*-elf)
2334     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2335     ;;
2336   thumb-*-pe)
2337     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2338     ;;
2339   arm-*-riscix*)
2340     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2341     ;;
2342   avr-*-*)
2343     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2344     ;;
2345   bfin-*-*)
2346     noconfigdirs="$noconfigdirs gdb"
2347     if test x${is_cross_compiler} != xno ; then
2348       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2349     fi
2350     ;;
2351   c4x-*-* | tic4x-*-*)
2352     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2353     ;;
2354   c54x*-*-* | tic54x-*-*)
2355     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2356     ;;
2357   cr16-*-*)
2358     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2359     ;;
2360   cris-*-* | crisv32-*-*)
2361     unsupported_languages="$unsupported_languages java"
2362     case "${target}" in
2363       *-*-aout)
2364         unsupported_languages="$unsupported_languages fortran"
2365         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2366       *-*-elf)
2367         noconfigdirs="$noconfigdirs target-boehm-gc";;
2368       *-*-linux*)
2369         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2370       *)
2371         unsupported_languages="$unsupported_languages fortran"
2372         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2373     esac
2374     libgloss_dir=cris
2375     ;;
2376   crx-*-*)
2377     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2378     ;;
2379   d10v-*-*)
2380     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2381     ;;
2382   d30v-*-*)
2383     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2384     ;;
2385   ep9312-*-elf | ep9312-*-coff)
2386     libgloss_dir=arm
2387     ;;
2388   fr30-*-elf*)
2389     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2390     ;;
2391   frv-*-*)
2392     noconfigdirs="$noconfigdirs ${libgcj}"
2393     ;;
2394   h8300*-*-*)
2395     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2396     ;;
2397   h8500-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2401     ;;
2402   hppa*64*-*-linux* | parisc*64*-*-linux*)
2403     # In this case, it's because the hppa64-linux target is for
2404     # the kernel only at this point and has no libc, and thus no
2405     # headers, crt*.o, etc., all of which are needed by these.
2406     noconfigdirs="$noconfigdirs target-zlib"
2407     ;;
2408   parisc*-*-linux* | hppa*-*-linux*)
2409     ;;
2410   hppa*-*-*elf* | \
2411   hppa*-*-lites* | \
2412   hppa*-*-openbsd* | \
2413   hppa*64*-*-*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   hppa*-hp-hpux11*)
2417     noconfigdirs="$noconfigdirs ld shellutils"
2418     ;;
2419   hppa*-*-pro*)
2420     libgloss_dir=pa
2421     ;;
2422   hppa*-*-*)
2423     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2424     # build on HP-UX 10.20.
2425     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2426     ;;
2427   i960-*-*)
2428     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2429     ;;
2430   ia64*-*-elf*)
2431     # No gdb support yet.
2432     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2433     ;;
2434   ia64*-**-hpux*)
2435     # No gdb or ld support yet.
2436     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2437     ;;
2438   i370-*-opened*)
2439     ;;
2440   i[3456789]86-*-coff | i[3456789]86-*-elf)
2441     noconfigdirs="$noconfigdirs ${libgcj}"
2442     libgloss_dir=i386
2443     ;;
2444   i[3456789]86-*-linux*)
2445     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2446     # not build java stuff by default.
2447     case "${target}" in
2448       *-*-*libc1*)
2449         noconfigdirs="$noconfigdirs ${libgcj}";;
2450     esac
2451
2452     # This section makes it possible to build newlib natively on linux.
2453     # If we are using a cross compiler then don't configure newlib.
2454     if test x${is_cross_compiler} != xno ; then
2455       noconfigdirs="$noconfigdirs target-newlib"
2456     fi
2457     noconfigdirs="$noconfigdirs target-libgloss"
2458     # If we are not using a cross compiler, do configure newlib.
2459     # Note however, that newlib will only be configured in this situation
2460     # if the --with-newlib option has been given, because otherwise
2461     # 'target-newlib' will appear in skipdirs.
2462     ;;
2463   i[3456789]86-*-mingw32*)
2464     target_configdirs="$target_configdirs target-winsup"
2465     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2466     ;;
2467   x86_64-*-mingw*)
2468     target_configdirs="$target_configdirs target-winsup"
2469     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2470     ;;
2471   *-*-cygwin*)
2472     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2473     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2474     # always build newlib if winsup directory is present.
2475     if test -d "$srcdir/winsup/cygwin"; then
2476       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2477     elif test -d "$srcdir/newlib"; then
2478       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2479     fi
2480     ;;
2481   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2482   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2483     ;;
2484   i[3456789]86-*-pe)
2485     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-sco3.2v5*)
2488     # The linker does not yet know about weak symbols in COFF,
2489     # and is not configured to handle mixed ELF and COFF.
2490     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2491     ;;
2492   i[3456789]86-*-sco*)
2493     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2494     ;;
2495   i[3456789]86-*-solaris2*)
2496     noconfigdirs="$noconfigdirs target-libgloss"
2497     ;;
2498   i[3456789]86-*-sysv4*)
2499     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2500     ;;
2501   i[3456789]86-*-beos*)
2502     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2503     ;;
2504   i[3456789]86-*-rdos*)
2505     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2506     ;;
2507   m32r-*-*)
2508     noconfigdirs="$noconfigdirs ${libgcj}"
2509     ;;
2510   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2511     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2512     libgloss_dir=m68hc11
2513     ;;
2514   m68k-*-elf*)
2515     noconfigdirs="$noconfigdirs ${libgcj}"
2516     ;;
2517   m68k-*-coff*)
2518     noconfigdirs="$noconfigdirs ${libgcj}"
2519     ;;
2520   m68*-*-* | fido-*-*)
2521     libgloss_dir=m68k
2522     ;;
2523   mcore-*-pe*)
2524   # The EPOC C++ environment does not support exceptions or rtti,
2525   # and so building libstdc++-v3 tends not to always work.
2526     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2527     ;;
2528   mmix-*-*)
2529     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2530     unsupported_languages="$unsupported_languages fortran java"
2531     ;;
2532   mn10200-*-*)
2533     noconfigdirs="$noconfigdirs ${libgcj}"
2534     ;;
2535   mn10300-*-*)
2536     noconfigdirs="$noconfigdirs ${libgcj}"
2537     ;;
2538   mt-*-*)
2539     noconfigdirs="$noconfigdirs sim"
2540     ;;
2541   powerpc-*-aix*)
2542     # copied from rs6000-*-* entry
2543     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2544     ;;
2545   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2546     target_configdirs="$target_configdirs target-winsup"
2547     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2548     # always build newlib.
2549     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2550     ;;
2551     # This is temporary until we can link against shared libraries
2552   powerpcle-*-solaris*)
2553     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2554     libgloss_dir=rs6000
2555     ;;
2556   powerpc-*-beos*)
2557     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2558     ;;
2559   powerpc-*-eabi)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=rs6000
2562     ;;
2563   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2564     libgloss_dir=rs6000
2565     ;;
2566   rs6000-*-lynxos*)
2567     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2568     ;;
2569   rs6000-*-aix*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2571     ;;
2572   rs6000-*-*)
2573     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2574     ;;
2575   m68k-apollo-*)
2576     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2577     ;;
2578   mips*-sde-elf*)
2579     skipdirs="$skipdirs target-libiberty"
2580     noconfigdirs="$noconfigdirs ${libgcj}"
2581     if test x$with_newlib = xyes; then
2582       noconfigdirs="$noconfigdirs gprof"
2583     fi
2584     libgloss_dir=mips
2585     ;;
2586   mips*-*-irix5*)
2587     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2588     ;;
2589   mips*-*-irix6*)
2590     # Linking libjava exceeds command-line length limits on at least
2591     # IRIX 6.2, but not on IRIX 6.5.
2592     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2593     # <oldham@codesourcery.com>
2594     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2595     ;;
2596   mips*-*-bsd*)
2597     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2598     ;;
2599   mips*-*-linux*)
2600     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2601     ;;
2602   mips*-*-*)
2603     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2604     libgloss_dir=mips
2605     ;;
2606   romp-*-*)
2607     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2608     ;;
2609   sh-*-* | sh64-*-*)
2610     case "${host}" in
2611       i[3456789]86-*-vsta) ;; # don't add gprof back in
2612       i[3456789]86-*-go32*) ;; # don't add gprof back in
2613       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2614       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2615     esac
2616     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2617     ;;
2618   sparclet-*-aout* | sparc86x-*-*)
2619     libgloss_dir=sparc
2620     ;;
2621   sparc-*-elf*)
2622     noconfigdirs="$noconfigdirs ${libgcj}"
2623     ;;
2624   sparc64-*-elf*)
2625     noconfigdirs="$noconfigdirs ${libgcj}"
2626     libgloss_dir=sparc
2627     ;;
2628   sparclite-*-*)
2629     noconfigdirs="$noconfigdirs ${libgcj}"
2630     libgloss_dir=sparc
2631     ;;
2632   sparc-*-sunos4*)
2633     noconfigdirs="$noconfigdirs ${libgcj}"
2634     if test x${is_cross_compiler} != xno ; then
2635            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2636     else
2637            use_gnu_ld=no
2638     fi
2639     ;;
2640   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2641     noconfigdirs="$noconfigdirs ${libgcj}"
2642     ;;
2643   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2644     ;;
2645   spu-*-*)
2646     skipdirs="target-libssp"
2647     ;;
2648   v810-*-*)
2649     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2650     ;;
2651   v850-*-*)
2652     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2653     ;;
2654   v850e-*-*)
2655     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2656     ;;
2657   v850ea-*-*)
2658     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2659     ;;
2660   vax-*-vms)
2661     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2662     ;;
2663   vax-*-*)
2664     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2665     ;;
2666   xtensa*-*-*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     ;;
2669   ip2k-*-*)
2670     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2671     ;;
2672   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2673     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2674     ;;
2675   *-*-lynxos*)
2676     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2677     ;;
2678   *-*-*)
2679     noconfigdirs="$noconfigdirs ${libgcj}"
2680     ;;
2681 esac
2682
2683 # If we aren't building newlib, then don't build libgloss, since libgloss
2684 # depends upon some newlib header files.
2685 case "${noconfigdirs}" in
2686   *target-libgloss*) ;;
2687   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2688 esac
2689
2690 # Work in distributions that contain no compiler tools, like Autoconf.
2691 tentative_cc=""
2692 host_makefile_frag=/dev/null
2693 if test -d ${srcdir}/config ; then
2694 case "${host}" in
2695   m68k-hp-hpux*)
2696     # Avoid "too much defining" errors from HPUX compiler.
2697     tentative_cc="cc -Wp,-H256000"
2698     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2699     # If it's HP/UX ar, this should be harmless.
2700     RANLIB="ar ts"
2701     ;;
2702   m68k-apollo-sysv*)
2703     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2704     ;;
2705   m68k-apollo-bsd*)
2706     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2707     # chokes on bfd, the compiler won't let you assign integers to enums, and
2708     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2709     # the apollo compiler" (the preferred version of GCC could be called cc,
2710     # or whatever), but I'm not sure leaving CC as cc is any better...
2711     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2712     # Used to have BISON=yacc.
2713     tentative_cc=gcc
2714     ;;
2715   m88k-dg-dgux*)
2716     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2717     ;;
2718   m88k-harris-cxux*)
2719     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2720     tentative_cc="cc -Xa"
2721     host_makefile_frag="config/mh-cxux"
2722     ;;
2723   m88k-motorola-sysv*)
2724     ;;
2725   mips*-dec-ultrix*)
2726     tentative_cc="cc -Wf,-XNg1000"
2727     host_makefile_frag="config/mh-decstation"
2728     ;;
2729   mips*-nec-sysv4*)
2730     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2731     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2732     host_makefile_frag="config/mh-necv4"
2733     ;;
2734   mips*-sgi-irix4*)
2735     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2736     # environment.  Also bump switch table size so that cp-parse will
2737     # compile.  Bump string length limit so linker builds.
2738     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2739     ;;
2740   mips*-*-sysv4*)
2741     host_makefile_frag="config/mh-sysv4"
2742     ;;
2743   mips*-*-sysv*)
2744     # This is for a MIPS running RISC/os 4.52C.
2745
2746     # This is needed for GDB, but needs to be in the top-level make because
2747     # if a library is compiled with the bsd headers and gets linked with the
2748     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2749     # a different size).
2750     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2751     # known except to select the sysv environment.  Could we use /proc instead?
2752     # These "sysv environments" and "bsd environments" often end up being a pain.
2753     #
2754     # This is not part of CFLAGS because perhaps not all C compilers have this
2755     # option.
2756     tentative_cc="cc -systype sysv"
2757     ;;
2758   i370-ibm-opened*)
2759     tentative_cc="c89"
2760     ;;
2761   i[3456789]86-*-sysv5*)
2762     host_makefile_frag="config/mh-sysv5"
2763     ;;
2764   i[3456789]86-*-dgux*)
2765     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2766     host_makefile_frag="config/mh-dgux386"
2767     ;;
2768   i[3456789]86-ncr-sysv4.3*)
2769     # The MetaWare compiler will generate a copyright message unless you
2770     # turn it off by adding the -Hnocopyr flag.
2771     tentative_cc="cc -Hnocopyr"
2772     ;;
2773   i[3456789]86-ncr-sysv4*)
2774     # for an NCR 3000 (i486/SVR4) system.
2775     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2776     # This compiler not only emits obnoxious copyright messages every time
2777     # you run it, but it chokes and dies on a whole bunch of GNU source
2778     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2779     tentative_cc="/usr/ccs/ATT/cc"
2780     host_makefile_frag="config/mh-ncr3000"
2781     ;;
2782   i[3456789]86-*-sco3.2v5*)
2783     ;;
2784   i[3456789]86-*-sco*)
2785     # The native C compiler botches some simple uses of const.  Unfortunately,
2786     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2787     tentative_cc="cc -Dconst="
2788     host_makefile_frag="config/mh-sco"
2789     ;;
2790   i[3456789]86-*-udk*)
2791     host_makefile_frag="config/mh-sysv5"
2792     ;;
2793   i[3456789]86-*-solaris2*)
2794     host_makefile_frag="config/mh-sysv4"
2795     ;;
2796   i[3456789]86-*-msdosdjgpp*)
2797     host_makefile_frag="config/mh-djgpp"
2798     ;;
2799   *-cygwin*)
2800
2801 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2802 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2803 echo a >cygwin-cat-check
2804 if test `cat cygwin-cat-check` == a ; then
2805   rm cygwin-cat-check
2806   echo "$as_me:$LINENO: result: yes" >&5
2807 echo "${ECHO_T}yes" >&6
2808 else
2809   rm cygwin-cat-check
2810   echo "$as_me:$LINENO: result: no" >&5
2811 echo "${ECHO_T}no" >&6
2812   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2813   Please either mount the build directory in binary mode or run the following
2814   commands before running any configure script:
2815 set -o igncr
2816 export SHELLOPTS
2817   " >&5
2818 echo "$as_me: error: The cat command does not ignore carriage return characters.
2819   Please either mount the build directory in binary mode or run the following
2820   commands before running any configure script:
2821 set -o igncr
2822 export SHELLOPTS
2823   " >&2;}
2824    { (exit 1); exit 1; }; }
2825 fi
2826
2827     host_makefile_frag="config/mh-cygwin"
2828     ;;
2829   *-mingw*)
2830     host_makefile_frag="config/mh-mingw"
2831     ;;
2832   *-interix*)
2833     host_makefile_frag="config/mh-interix"
2834     ;;
2835   vax-*-ultrix2*)
2836     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2837     tentative_cc=gcc
2838     ;;
2839   *-*-solaris2*)
2840     host_makefile_frag="config/mh-solaris"
2841     ;;
2842   m68k-sun-sunos*)
2843     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2844     # without overflowing the jump tables (-J says to use a 32 bit table)
2845     tentative_cc="cc -J"
2846     ;;
2847   hppa*-hp-hpux10*)
2848     tentative_cc="cc -Wp,-H256000"
2849     host_makefile_frag="config/mh-pa-hpux10"
2850     ;;
2851   hppa*-hp-hpux* | hppa*-*-hiux*)
2852     tentative_cc="cc -Wp,-H256000"
2853     host_makefile_frag="config/mh-pa"
2854     ;;
2855   hppa*-*)
2856     host_makefile_frag="config/mh-pa"
2857     ;;
2858   *-hp-hpux* | *-*-hiux*)
2859     tentative_cc="cc -Wp,-H256000"
2860     ;;
2861   rs6000-*-lynxos*)
2862     # /bin/cc is less than useful for our purposes.  Always use GCC
2863     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2864     host_makefile_frag="config/mh-lynxrs6k"
2865     ;;
2866   powerpc-*-darwin*)
2867     host_makefile_frag="config/mh-ppc-darwin"
2868     ;;
2869   powerpc-*-aix*)
2870     host_makefile_frag="config/mh-ppc-aix"
2871     ;;
2872   rs6000-*-aix*)
2873     host_makefile_frag="config/mh-ppc-aix"
2874     ;;
2875   *-*-lynxos*)
2876     # /bin/cc is less than useful for our purposes.  Always use GCC
2877     tentative_cc="/bin/gcc"
2878     ;;
2879   *-*-sysv4*)
2880     host_makefile_frag="config/mh-sysv4"
2881     ;;
2882   # This is placed last to prevent interfering with the cases above.
2883   i[3456789]86-*-*)
2884     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2885     host_makefile_frag="config/mh-x86omitfp"
2886     ;;
2887 esac
2888 fi
2889
2890 # If we aren't going to be using gcc, see if we can extract a definition
2891 # of CC from the fragment.
2892 # Actually, use the 'pre-extracted' version above.
2893 if test -z "${CC}" && test "${build}" = "${host}" ; then
2894   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2895   found=
2896   for dir in $PATH; do
2897     test -z "$dir" && dir=.
2898     if test -f $dir/gcc; then
2899       found=yes
2900       break
2901     fi
2902   done
2903   IFS="$save_ifs"
2904   if test -z "${found}" && test -n "${tentative_cc}" ; then
2905     CC=$tentative_cc
2906   fi
2907 fi
2908
2909 if test "${build}" != "${host}" ; then
2910   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2911   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2912   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2913   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2914   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2915   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2916   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2917   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2918   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2919   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2920   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2921   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2922 else
2923   AR_FOR_BUILD="\$(AR)"
2924   AS_FOR_BUILD="\$(AS)"
2925   CC_FOR_BUILD="\$(CC)"
2926   CXX_FOR_BUILD="\$(CXX)"
2927   GCJ_FOR_BUILD="\$(GCJ)"
2928   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2929   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2930   LD_FOR_BUILD="\$(LD)"
2931   NM_FOR_BUILD="\$(NM)"
2932   RANLIB_FOR_BUILD="\$(RANLIB)"
2933   WINDRES_FOR_BUILD="\$(WINDRES)"
2934   WINDMC_FOR_BUILD="\$(WINDMC)"
2935 fi
2936
2937 ac_ext=c
2938 ac_cpp='$CPP $CPPFLAGS'
2939 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2940 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2941 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2942 if test -n "$ac_tool_prefix"; then
2943   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2944 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2945 echo "$as_me:$LINENO: checking for $ac_word" >&5
2946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2947 if test "${ac_cv_prog_CC+set}" = set; then
2948   echo $ECHO_N "(cached) $ECHO_C" >&6
2949 else
2950   if test -n "$CC"; then
2951   ac_cv_prog_CC="$CC" # Let the user override the test.
2952 else
2953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2954 for as_dir in $PATH
2955 do
2956   IFS=$as_save_IFS
2957   test -z "$as_dir" && as_dir=.
2958   for ac_exec_ext in '' $ac_executable_extensions; do
2959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2960     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2962     break 2
2963   fi
2964 done
2965 done
2966
2967 fi
2968 fi
2969 CC=$ac_cv_prog_CC
2970 if test -n "$CC"; then
2971   echo "$as_me:$LINENO: result: $CC" >&5
2972 echo "${ECHO_T}$CC" >&6
2973 else
2974   echo "$as_me:$LINENO: result: no" >&5
2975 echo "${ECHO_T}no" >&6
2976 fi
2977
2978 fi
2979 if test -z "$ac_cv_prog_CC"; then
2980   ac_ct_CC=$CC
2981   # Extract the first word of "gcc", so it can be a program name with args.
2982 set dummy gcc; ac_word=$2
2983 echo "$as_me:$LINENO: checking for $ac_word" >&5
2984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2985 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2986   echo $ECHO_N "(cached) $ECHO_C" >&6
2987 else
2988   if test -n "$ac_ct_CC"; then
2989   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2990 else
2991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2992 for as_dir in $PATH
2993 do
2994   IFS=$as_save_IFS
2995   test -z "$as_dir" && as_dir=.
2996   for ac_exec_ext in '' $ac_executable_extensions; do
2997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2998     ac_cv_prog_ac_ct_CC="gcc"
2999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3000     break 2
3001   fi
3002 done
3003 done
3004
3005 fi
3006 fi
3007 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3008 if test -n "$ac_ct_CC"; then
3009   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3010 echo "${ECHO_T}$ac_ct_CC" >&6
3011 else
3012   echo "$as_me:$LINENO: result: no" >&5
3013 echo "${ECHO_T}no" >&6
3014 fi
3015
3016   CC=$ac_ct_CC
3017 else
3018   CC="$ac_cv_prog_CC"
3019 fi
3020
3021 if test -z "$CC"; then
3022   if test -n "$ac_tool_prefix"; then
3023   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3024 set dummy ${ac_tool_prefix}cc; ac_word=$2
3025 echo "$as_me:$LINENO: checking for $ac_word" >&5
3026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3027 if test "${ac_cv_prog_CC+set}" = set; then
3028   echo $ECHO_N "(cached) $ECHO_C" >&6
3029 else
3030   if test -n "$CC"; then
3031   ac_cv_prog_CC="$CC" # Let the user override the test.
3032 else
3033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3034 for as_dir in $PATH
3035 do
3036   IFS=$as_save_IFS
3037   test -z "$as_dir" && as_dir=.
3038   for ac_exec_ext in '' $ac_executable_extensions; do
3039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3040     ac_cv_prog_CC="${ac_tool_prefix}cc"
3041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3042     break 2
3043   fi
3044 done
3045 done
3046
3047 fi
3048 fi
3049 CC=$ac_cv_prog_CC
3050 if test -n "$CC"; then
3051   echo "$as_me:$LINENO: result: $CC" >&5
3052 echo "${ECHO_T}$CC" >&6
3053 else
3054   echo "$as_me:$LINENO: result: no" >&5
3055 echo "${ECHO_T}no" >&6
3056 fi
3057
3058 fi
3059 if test -z "$ac_cv_prog_CC"; then
3060   ac_ct_CC=$CC
3061   # Extract the first word of "cc", so it can be a program name with args.
3062 set dummy cc; ac_word=$2
3063 echo "$as_me:$LINENO: checking for $ac_word" >&5
3064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3065 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3066   echo $ECHO_N "(cached) $ECHO_C" >&6
3067 else
3068   if test -n "$ac_ct_CC"; then
3069   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3070 else
3071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3072 for as_dir in $PATH
3073 do
3074   IFS=$as_save_IFS
3075   test -z "$as_dir" && as_dir=.
3076   for ac_exec_ext in '' $ac_executable_extensions; do
3077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3078     ac_cv_prog_ac_ct_CC="cc"
3079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3080     break 2
3081   fi
3082 done
3083 done
3084
3085 fi
3086 fi
3087 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3088 if test -n "$ac_ct_CC"; then
3089   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3090 echo "${ECHO_T}$ac_ct_CC" >&6
3091 else
3092   echo "$as_me:$LINENO: result: no" >&5
3093 echo "${ECHO_T}no" >&6
3094 fi
3095
3096   CC=$ac_ct_CC
3097 else
3098   CC="$ac_cv_prog_CC"
3099 fi
3100
3101 fi
3102 if test -z "$CC"; then
3103   # Extract the first word of "cc", so it can be a program name with args.
3104 set dummy cc; ac_word=$2
3105 echo "$as_me:$LINENO: checking for $ac_word" >&5
3106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3107 if test "${ac_cv_prog_CC+set}" = set; then
3108   echo $ECHO_N "(cached) $ECHO_C" >&6
3109 else
3110   if test -n "$CC"; then
3111   ac_cv_prog_CC="$CC" # Let the user override the test.
3112 else
3113   ac_prog_rejected=no
3114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3115 for as_dir in $PATH
3116 do
3117   IFS=$as_save_IFS
3118   test -z "$as_dir" && as_dir=.
3119   for ac_exec_ext in '' $ac_executable_extensions; do
3120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3121     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3122        ac_prog_rejected=yes
3123        continue
3124      fi
3125     ac_cv_prog_CC="cc"
3126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3127     break 2
3128   fi
3129 done
3130 done
3131
3132 if test $ac_prog_rejected = yes; then
3133   # We found a bogon in the path, so make sure we never use it.
3134   set dummy $ac_cv_prog_CC
3135   shift
3136   if test $# != 0; then
3137     # We chose a different compiler from the bogus one.
3138     # However, it has the same basename, so the bogon will be chosen
3139     # first if we set CC to just the basename; use the full file name.
3140     shift
3141     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3142   fi
3143 fi
3144 fi
3145 fi
3146 CC=$ac_cv_prog_CC
3147 if test -n "$CC"; then
3148   echo "$as_me:$LINENO: result: $CC" >&5
3149 echo "${ECHO_T}$CC" >&6
3150 else
3151   echo "$as_me:$LINENO: result: no" >&5
3152 echo "${ECHO_T}no" >&6
3153 fi
3154
3155 fi
3156 if test -z "$CC"; then
3157   if test -n "$ac_tool_prefix"; then
3158   for ac_prog in cl
3159   do
3160     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3161 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3162 echo "$as_me:$LINENO: checking for $ac_word" >&5
3163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3164 if test "${ac_cv_prog_CC+set}" = set; then
3165   echo $ECHO_N "(cached) $ECHO_C" >&6
3166 else
3167   if test -n "$CC"; then
3168   ac_cv_prog_CC="$CC" # Let the user override the test.
3169 else
3170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3171 for as_dir in $PATH
3172 do
3173   IFS=$as_save_IFS
3174   test -z "$as_dir" && as_dir=.
3175   for ac_exec_ext in '' $ac_executable_extensions; do
3176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3177     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3179     break 2
3180   fi
3181 done
3182 done
3183
3184 fi
3185 fi
3186 CC=$ac_cv_prog_CC
3187 if test -n "$CC"; then
3188   echo "$as_me:$LINENO: result: $CC" >&5
3189 echo "${ECHO_T}$CC" >&6
3190 else
3191   echo "$as_me:$LINENO: result: no" >&5
3192 echo "${ECHO_T}no" >&6
3193 fi
3194
3195     test -n "$CC" && break
3196   done
3197 fi
3198 if test -z "$CC"; then
3199   ac_ct_CC=$CC
3200   for ac_prog in cl
3201 do
3202   # Extract the first word of "$ac_prog", so it can be a program name with args.
3203 set dummy $ac_prog; ac_word=$2
3204 echo "$as_me:$LINENO: checking for $ac_word" >&5
3205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3206 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3207   echo $ECHO_N "(cached) $ECHO_C" >&6
3208 else
3209   if test -n "$ac_ct_CC"; then
3210   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3211 else
3212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3213 for as_dir in $PATH
3214 do
3215   IFS=$as_save_IFS
3216   test -z "$as_dir" && as_dir=.
3217   for ac_exec_ext in '' $ac_executable_extensions; do
3218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3219     ac_cv_prog_ac_ct_CC="$ac_prog"
3220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3221     break 2
3222   fi
3223 done
3224 done
3225
3226 fi
3227 fi
3228 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3229 if test -n "$ac_ct_CC"; then
3230   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3231 echo "${ECHO_T}$ac_ct_CC" >&6
3232 else
3233   echo "$as_me:$LINENO: result: no" >&5
3234 echo "${ECHO_T}no" >&6
3235 fi
3236
3237   test -n "$ac_ct_CC" && break
3238 done
3239
3240   CC=$ac_ct_CC
3241 fi
3242
3243 fi
3244
3245
3246 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3247 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3248 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3249 See \`config.log' for more details." >&5
3250 echo "$as_me: error: no acceptable C compiler found in \$PATH
3251 See \`config.log' for more details." >&2;}
3252    { (exit 1); exit 1; }; }; }
3253
3254 # Provide some information about the compiler.
3255 echo "$as_me:$LINENO:" \
3256      "checking for C compiler version" >&5
3257 ac_compiler=`set X $ac_compile; echo $2`
3258 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3259   (eval $ac_compiler --version </dev/null >&5) 2>&5
3260   ac_status=$?
3261   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3262   (exit $ac_status); }
3263 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3264   (eval $ac_compiler -v </dev/null >&5) 2>&5
3265   ac_status=$?
3266   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3267   (exit $ac_status); }
3268 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3269   (eval $ac_compiler -V </dev/null >&5) 2>&5
3270   ac_status=$?
3271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3272   (exit $ac_status); }
3273
3274 cat >conftest.$ac_ext <<_ACEOF
3275 /* confdefs.h.  */
3276 _ACEOF
3277 cat confdefs.h >>conftest.$ac_ext
3278 cat >>conftest.$ac_ext <<_ACEOF
3279 /* end confdefs.h.  */
3280
3281 int
3282 main ()
3283 {
3284
3285   ;
3286   return 0;
3287 }
3288 _ACEOF
3289 ac_clean_files_save=$ac_clean_files
3290 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3291 # Try to create an executable without -o first, disregard a.out.
3292 # It will help us diagnose broken compilers, and finding out an intuition
3293 # of exeext.
3294 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3295 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3296 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3297 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3298   (eval $ac_link_default) 2>&5
3299   ac_status=$?
3300   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3301   (exit $ac_status); }; then
3302   # Find the output, starting from the most likely.  This scheme is
3303 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3304 # resort.
3305
3306 # Be careful to initialize this variable, since it used to be cached.
3307 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3308 ac_cv_exeext=
3309 # b.out is created by i960 compilers.
3310 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3311 do
3312   test -f "$ac_file" || continue
3313   case $ac_file in
3314     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3315         ;;
3316     conftest.$ac_ext )
3317         # This is the source file.
3318         ;;
3319     [ab].out )
3320         # We found the default executable, but exeext='' is most
3321         # certainly right.
3322         break;;
3323     *.* )
3324         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3325         # FIXME: I believe we export ac_cv_exeext for Libtool,
3326         # but it would be cool to find out if it's true.  Does anybody
3327         # maintain Libtool? --akim.
3328         export ac_cv_exeext
3329         break;;
3330     * )
3331         break;;
3332   esac
3333 done
3334 else
3335   echo "$as_me: failed program was:" >&5
3336 sed 's/^/| /' conftest.$ac_ext >&5
3337
3338 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3339 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3340 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3341 See \`config.log' for more details." >&5
3342 echo "$as_me: error: C compiler cannot create executables
3343 See \`config.log' for more details." >&2;}
3344    { (exit 77); exit 77; }; }; }
3345 fi
3346
3347 ac_exeext=$ac_cv_exeext
3348 echo "$as_me:$LINENO: result: $ac_file" >&5
3349 echo "${ECHO_T}$ac_file" >&6
3350
3351 # Check the compiler produces executables we can run.  If not, either
3352 # the compiler is broken, or we cross compile.
3353 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3354 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3355 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3356 # If not cross compiling, check that we can run a simple program.
3357 if test "$cross_compiling" != yes; then
3358   if { ac_try='./$ac_file'
3359   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3360   (eval $ac_try) 2>&5
3361   ac_status=$?
3362   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3363   (exit $ac_status); }; }; then
3364     cross_compiling=no
3365   else
3366     if test "$cross_compiling" = maybe; then
3367         cross_compiling=yes
3368     else
3369         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3370 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3371 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3372 If you meant to cross compile, use \`--host'.
3373 See \`config.log' for more details." >&5
3374 echo "$as_me: error: cannot run C compiled programs.
3375 If you meant to cross compile, use \`--host'.
3376 See \`config.log' for more details." >&2;}
3377    { (exit 1); exit 1; }; }; }
3378     fi
3379   fi
3380 fi
3381 echo "$as_me:$LINENO: result: yes" >&5
3382 echo "${ECHO_T}yes" >&6
3383
3384 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3385 ac_clean_files=$ac_clean_files_save
3386 # Check the compiler produces executables we can run.  If not, either
3387 # the compiler is broken, or we cross compile.
3388 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3389 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3390 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3391 echo "${ECHO_T}$cross_compiling" >&6
3392
3393 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3394 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3395 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3396   (eval $ac_link) 2>&5
3397   ac_status=$?
3398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3399   (exit $ac_status); }; then
3400   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3401 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3402 # work properly (i.e., refer to `conftest.exe'), while it won't with
3403 # `rm'.
3404 for ac_file in conftest.exe conftest conftest.*; do
3405   test -f "$ac_file" || continue
3406   case $ac_file in
3407     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3408     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3409           export ac_cv_exeext
3410           break;;
3411     * ) break;;
3412   esac
3413 done
3414 else
3415   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3416 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3417 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3418 See \`config.log' for more details." >&5
3419 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3420 See \`config.log' for more details." >&2;}
3421    { (exit 1); exit 1; }; }; }
3422 fi
3423
3424 rm -f conftest$ac_cv_exeext
3425 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3426 echo "${ECHO_T}$ac_cv_exeext" >&6
3427
3428 rm -f conftest.$ac_ext
3429 EXEEXT=$ac_cv_exeext
3430 ac_exeext=$EXEEXT
3431 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3432 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3433 if test "${ac_cv_objext+set}" = set; then
3434   echo $ECHO_N "(cached) $ECHO_C" >&6
3435 else
3436   cat >conftest.$ac_ext <<_ACEOF
3437 /* confdefs.h.  */
3438 _ACEOF
3439 cat confdefs.h >>conftest.$ac_ext
3440 cat >>conftest.$ac_ext <<_ACEOF
3441 /* end confdefs.h.  */
3442
3443 int
3444 main ()
3445 {
3446
3447   ;
3448   return 0;
3449 }
3450 _ACEOF
3451 rm -f conftest.o conftest.obj
3452 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3453   (eval $ac_compile) 2>&5
3454   ac_status=$?
3455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3456   (exit $ac_status); }; then
3457   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3458   case $ac_file in
3459     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3460     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3461        break;;
3462   esac
3463 done
3464 else
3465   echo "$as_me: failed program was:" >&5
3466 sed 's/^/| /' conftest.$ac_ext >&5
3467
3468 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3469 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3470 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3471 See \`config.log' for more details." >&5
3472 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3473 See \`config.log' for more details." >&2;}
3474    { (exit 1); exit 1; }; }; }
3475 fi
3476
3477 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3478 fi
3479 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3480 echo "${ECHO_T}$ac_cv_objext" >&6
3481 OBJEXT=$ac_cv_objext
3482 ac_objext=$OBJEXT
3483 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3484 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3485 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3486   echo $ECHO_N "(cached) $ECHO_C" >&6
3487 else
3488   cat >conftest.$ac_ext <<_ACEOF
3489 /* confdefs.h.  */
3490 _ACEOF
3491 cat confdefs.h >>conftest.$ac_ext
3492 cat >>conftest.$ac_ext <<_ACEOF
3493 /* end confdefs.h.  */
3494
3495 int
3496 main ()
3497 {
3498 #ifndef __GNUC__
3499        choke me
3500 #endif
3501
3502   ;
3503   return 0;
3504 }
3505 _ACEOF
3506 rm -f conftest.$ac_objext
3507 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3508   (eval $ac_compile) 2>conftest.er1
3509   ac_status=$?
3510   grep -v '^ *+' conftest.er1 >conftest.err
3511   rm -f conftest.er1
3512   cat conftest.err >&5
3513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3514   (exit $ac_status); } &&
3515          { ac_try='test -z "$ac_c_werror_flag"
3516                          || test ! -s conftest.err'
3517   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3518   (eval $ac_try) 2>&5
3519   ac_status=$?
3520   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3521   (exit $ac_status); }; } &&
3522          { ac_try='test -s conftest.$ac_objext'
3523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3524   (eval $ac_try) 2>&5
3525   ac_status=$?
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); }; }; then
3528   ac_compiler_gnu=yes
3529 else
3530   echo "$as_me: failed program was:" >&5
3531 sed 's/^/| /' conftest.$ac_ext >&5
3532
3533 ac_compiler_gnu=no
3534 fi
3535 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3536 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3537
3538 fi
3539 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3540 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3541 GCC=`test $ac_compiler_gnu = yes && echo yes`
3542 ac_test_CFLAGS=${CFLAGS+set}
3543 ac_save_CFLAGS=$CFLAGS
3544 CFLAGS="-g"
3545 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3546 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3547 if test "${ac_cv_prog_cc_g+set}" = set; then
3548   echo $ECHO_N "(cached) $ECHO_C" >&6
3549 else
3550   cat >conftest.$ac_ext <<_ACEOF
3551 /* confdefs.h.  */
3552 _ACEOF
3553 cat confdefs.h >>conftest.$ac_ext
3554 cat >>conftest.$ac_ext <<_ACEOF
3555 /* end confdefs.h.  */
3556
3557 int
3558 main ()
3559 {
3560
3561   ;
3562   return 0;
3563 }
3564 _ACEOF
3565 rm -f conftest.$ac_objext
3566 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3567   (eval $ac_compile) 2>conftest.er1
3568   ac_status=$?
3569   grep -v '^ *+' conftest.er1 >conftest.err
3570   rm -f conftest.er1
3571   cat conftest.err >&5
3572   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3573   (exit $ac_status); } &&
3574          { ac_try='test -z "$ac_c_werror_flag"
3575                          || test ! -s conftest.err'
3576   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3577   (eval $ac_try) 2>&5
3578   ac_status=$?
3579   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3580   (exit $ac_status); }; } &&
3581          { ac_try='test -s conftest.$ac_objext'
3582   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3583   (eval $ac_try) 2>&5
3584   ac_status=$?
3585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3586   (exit $ac_status); }; }; then
3587   ac_cv_prog_cc_g=yes
3588 else
3589   echo "$as_me: failed program was:" >&5
3590 sed 's/^/| /' conftest.$ac_ext >&5
3591
3592 ac_cv_prog_cc_g=no
3593 fi
3594 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3595 fi
3596 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3597 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3598 if test "$ac_test_CFLAGS" = set; then
3599   CFLAGS=$ac_save_CFLAGS
3600 elif test $ac_cv_prog_cc_g = yes; then
3601   if test "$GCC" = yes; then
3602     CFLAGS="-g -O2"
3603   else
3604     CFLAGS="-g"
3605   fi
3606 else
3607   if test "$GCC" = yes; then
3608     CFLAGS="-O2"
3609   else
3610     CFLAGS=
3611   fi
3612 fi
3613 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3614 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3615 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3616   echo $ECHO_N "(cached) $ECHO_C" >&6
3617 else
3618   ac_cv_prog_cc_stdc=no
3619 ac_save_CC=$CC
3620 cat >conftest.$ac_ext <<_ACEOF
3621 /* confdefs.h.  */
3622 _ACEOF
3623 cat confdefs.h >>conftest.$ac_ext
3624 cat >>conftest.$ac_ext <<_ACEOF
3625 /* end confdefs.h.  */
3626 #include <stdarg.h>
3627 #include <stdio.h>
3628 #include <sys/types.h>
3629 #include <sys/stat.h>
3630 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3631 struct buf { int x; };
3632 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3633 static char *e (p, i)
3634      char **p;
3635      int i;
3636 {
3637   return p[i];
3638 }
3639 static char *f (char * (*g) (char **, int), char **p, ...)
3640 {
3641   char *s;
3642   va_list v;
3643   va_start (v,p);
3644   s = g (p, va_arg (v,int));
3645   va_end (v);
3646   return s;
3647 }
3648
3649 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3650    function prototypes and stuff, but not '\xHH' hex character constants.
3651    These don't provoke an error unfortunately, instead are silently treated
3652    as 'x'.  The following induces an error, until -std1 is added to get
3653    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3654    array size at least.  It's necessary to write '\x00'==0 to get something
3655    that's true only with -std1.  */
3656 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3657
3658 int test (int i, double x);
3659 struct s1 {int (*f) (int a);};
3660 struct s2 {int (*f) (double a);};
3661 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3662 int argc;
3663 char **argv;
3664 int
3665 main ()
3666 {
3667 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3668   ;
3669   return 0;
3670 }
3671 _ACEOF
3672 # Don't try gcc -ansi; that turns off useful extensions and
3673 # breaks some systems' header files.
3674 # AIX                   -qlanglvl=ansi
3675 # Ultrix and OSF/1      -std1
3676 # HP-UX 10.20 and later -Ae
3677 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3678 # SVR4                  -Xc -D__EXTENSIONS__
3679 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3680 do
3681   CC="$ac_save_CC $ac_arg"
3682   rm -f conftest.$ac_objext
3683 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3684   (eval $ac_compile) 2>conftest.er1
3685   ac_status=$?
3686   grep -v '^ *+' conftest.er1 >conftest.err
3687   rm -f conftest.er1
3688   cat conftest.err >&5
3689   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3690   (exit $ac_status); } &&
3691          { ac_try='test -z "$ac_c_werror_flag"
3692                          || test ! -s conftest.err'
3693   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3694   (eval $ac_try) 2>&5
3695   ac_status=$?
3696   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3697   (exit $ac_status); }; } &&
3698          { ac_try='test -s conftest.$ac_objext'
3699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3700   (eval $ac_try) 2>&5
3701   ac_status=$?
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); }; }; then
3704   ac_cv_prog_cc_stdc=$ac_arg
3705 break
3706 else
3707   echo "$as_me: failed program was:" >&5
3708 sed 's/^/| /' conftest.$ac_ext >&5
3709
3710 fi
3711 rm -f conftest.err conftest.$ac_objext
3712 done
3713 rm -f conftest.$ac_ext conftest.$ac_objext
3714 CC=$ac_save_CC
3715
3716 fi
3717
3718 case "x$ac_cv_prog_cc_stdc" in
3719   x|xno)
3720     echo "$as_me:$LINENO: result: none needed" >&5
3721 echo "${ECHO_T}none needed" >&6 ;;
3722   *)
3723     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3724 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3725     CC="$CC $ac_cv_prog_cc_stdc" ;;
3726 esac
3727
3728 # Some people use a C++ compiler to compile C.  Since we use `exit',
3729 # in C++ we need to declare it.  In case someone uses the same compiler
3730 # for both compiling C and C++ we need to have the C++ compiler decide
3731 # the declaration of exit, since it's the most demanding environment.
3732 cat >conftest.$ac_ext <<_ACEOF
3733 #ifndef __cplusplus
3734   choke me
3735 #endif
3736 _ACEOF
3737 rm -f conftest.$ac_objext
3738 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3739   (eval $ac_compile) 2>conftest.er1
3740   ac_status=$?
3741   grep -v '^ *+' conftest.er1 >conftest.err
3742   rm -f conftest.er1
3743   cat conftest.err >&5
3744   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3745   (exit $ac_status); } &&
3746          { ac_try='test -z "$ac_c_werror_flag"
3747                          || test ! -s conftest.err'
3748   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3749   (eval $ac_try) 2>&5
3750   ac_status=$?
3751   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3752   (exit $ac_status); }; } &&
3753          { ac_try='test -s conftest.$ac_objext'
3754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3755   (eval $ac_try) 2>&5
3756   ac_status=$?
3757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758   (exit $ac_status); }; }; then
3759   for ac_declaration in \
3760    '' \
3761    'extern "C" void std::exit (int) throw (); using std::exit;' \
3762    'extern "C" void std::exit (int); using std::exit;' \
3763    'extern "C" void exit (int) throw ();' \
3764    'extern "C" void exit (int);' \
3765    'void exit (int);'
3766 do
3767   cat >conftest.$ac_ext <<_ACEOF
3768 /* confdefs.h.  */
3769 _ACEOF
3770 cat confdefs.h >>conftest.$ac_ext
3771 cat >>conftest.$ac_ext <<_ACEOF
3772 /* end confdefs.h.  */
3773 $ac_declaration
3774 #include <stdlib.h>
3775 int
3776 main ()
3777 {
3778 exit (42);
3779   ;
3780   return 0;
3781 }
3782 _ACEOF
3783 rm -f conftest.$ac_objext
3784 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3785   (eval $ac_compile) 2>conftest.er1
3786   ac_status=$?
3787   grep -v '^ *+' conftest.er1 >conftest.err
3788   rm -f conftest.er1
3789   cat conftest.err >&5
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); } &&
3792          { ac_try='test -z "$ac_c_werror_flag"
3793                          || test ! -s conftest.err'
3794   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3795   (eval $ac_try) 2>&5
3796   ac_status=$?
3797   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3798   (exit $ac_status); }; } &&
3799          { ac_try='test -s conftest.$ac_objext'
3800   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3801   (eval $ac_try) 2>&5
3802   ac_status=$?
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); }; }; then
3805   :
3806 else
3807   echo "$as_me: failed program was:" >&5
3808 sed 's/^/| /' conftest.$ac_ext >&5
3809
3810 continue
3811 fi
3812 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3813   cat >conftest.$ac_ext <<_ACEOF
3814 /* confdefs.h.  */
3815 _ACEOF
3816 cat confdefs.h >>conftest.$ac_ext
3817 cat >>conftest.$ac_ext <<_ACEOF
3818 /* end confdefs.h.  */
3819 $ac_declaration
3820 int
3821 main ()
3822 {
3823 exit (42);
3824   ;
3825   return 0;
3826 }
3827 _ACEOF
3828 rm -f conftest.$ac_objext
3829 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3830   (eval $ac_compile) 2>conftest.er1
3831   ac_status=$?
3832   grep -v '^ *+' conftest.er1 >conftest.err
3833   rm -f conftest.er1
3834   cat conftest.err >&5
3835   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3836   (exit $ac_status); } &&
3837          { ac_try='test -z "$ac_c_werror_flag"
3838                          || test ! -s conftest.err'
3839   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3840   (eval $ac_try) 2>&5
3841   ac_status=$?
3842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3843   (exit $ac_status); }; } &&
3844          { ac_try='test -s conftest.$ac_objext'
3845   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3846   (eval $ac_try) 2>&5
3847   ac_status=$?
3848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3849   (exit $ac_status); }; }; then
3850   break
3851 else
3852   echo "$as_me: failed program was:" >&5
3853 sed 's/^/| /' conftest.$ac_ext >&5
3854
3855 fi
3856 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3857 done
3858 rm -f conftest*
3859 if test -n "$ac_declaration"; then
3860   echo '#ifdef __cplusplus' >>confdefs.h
3861   echo $ac_declaration      >>confdefs.h
3862   echo '#endif'             >>confdefs.h
3863 fi
3864
3865 else
3866   echo "$as_me: failed program was:" >&5
3867 sed 's/^/| /' conftest.$ac_ext >&5
3868
3869 fi
3870 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3871 ac_ext=c
3872 ac_cpp='$CPP $CPPFLAGS'
3873 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3874 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3875 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3876
3877 ac_ext=cc
3878 ac_cpp='$CXXCPP $CPPFLAGS'
3879 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3880 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3881 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3882 if test -n "$ac_tool_prefix"; then
3883   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3884   do
3885     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3886 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3887 echo "$as_me:$LINENO: checking for $ac_word" >&5
3888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3889 if test "${ac_cv_prog_CXX+set}" = set; then
3890   echo $ECHO_N "(cached) $ECHO_C" >&6
3891 else
3892   if test -n "$CXX"; then
3893   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3894 else
3895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3896 for as_dir in $PATH
3897 do
3898   IFS=$as_save_IFS
3899   test -z "$as_dir" && as_dir=.
3900   for ac_exec_ext in '' $ac_executable_extensions; do
3901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3902     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3904     break 2
3905   fi
3906 done
3907 done
3908
3909 fi
3910 fi
3911 CXX=$ac_cv_prog_CXX
3912 if test -n "$CXX"; then
3913   echo "$as_me:$LINENO: result: $CXX" >&5
3914 echo "${ECHO_T}$CXX" >&6
3915 else
3916   echo "$as_me:$LINENO: result: no" >&5
3917 echo "${ECHO_T}no" >&6
3918 fi
3919
3920     test -n "$CXX" && break
3921   done
3922 fi
3923 if test -z "$CXX"; then
3924   ac_ct_CXX=$CXX
3925   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3926 do
3927   # Extract the first word of "$ac_prog", so it can be a program name with args.
3928 set dummy $ac_prog; ac_word=$2
3929 echo "$as_me:$LINENO: checking for $ac_word" >&5
3930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3931 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3932   echo $ECHO_N "(cached) $ECHO_C" >&6
3933 else
3934   if test -n "$ac_ct_CXX"; then
3935   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3936 else
3937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3938 for as_dir in $PATH
3939 do
3940   IFS=$as_save_IFS
3941   test -z "$as_dir" && as_dir=.
3942   for ac_exec_ext in '' $ac_executable_extensions; do
3943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3944     ac_cv_prog_ac_ct_CXX="$ac_prog"
3945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3946     break 2
3947   fi
3948 done
3949 done
3950
3951 fi
3952 fi
3953 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3954 if test -n "$ac_ct_CXX"; then
3955   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3956 echo "${ECHO_T}$ac_ct_CXX" >&6
3957 else
3958   echo "$as_me:$LINENO: result: no" >&5
3959 echo "${ECHO_T}no" >&6
3960 fi
3961
3962   test -n "$ac_ct_CXX" && break
3963 done
3964 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3965
3966   CXX=$ac_ct_CXX
3967 fi
3968
3969
3970 # Provide some information about the compiler.
3971 echo "$as_me:$LINENO:" \
3972      "checking for C++ compiler version" >&5
3973 ac_compiler=`set X $ac_compile; echo $2`
3974 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3975   (eval $ac_compiler --version </dev/null >&5) 2>&5
3976   ac_status=$?
3977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978   (exit $ac_status); }
3979 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3980   (eval $ac_compiler -v </dev/null >&5) 2>&5
3981   ac_status=$?
3982   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3983   (exit $ac_status); }
3984 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3985   (eval $ac_compiler -V </dev/null >&5) 2>&5
3986   ac_status=$?
3987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3988   (exit $ac_status); }
3989
3990 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3991 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3992 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3993   echo $ECHO_N "(cached) $ECHO_C" >&6
3994 else
3995   cat >conftest.$ac_ext <<_ACEOF
3996 /* confdefs.h.  */
3997 _ACEOF
3998 cat confdefs.h >>conftest.$ac_ext
3999 cat >>conftest.$ac_ext <<_ACEOF
4000 /* end confdefs.h.  */
4001
4002 int
4003 main ()
4004 {
4005 #ifndef __GNUC__
4006        choke me
4007 #endif
4008
4009   ;
4010   return 0;
4011 }
4012 _ACEOF
4013 rm -f conftest.$ac_objext
4014 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4015   (eval $ac_compile) 2>conftest.er1
4016   ac_status=$?
4017   grep -v '^ *+' conftest.er1 >conftest.err
4018   rm -f conftest.er1
4019   cat conftest.err >&5
4020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4021   (exit $ac_status); } &&
4022          { ac_try='test -z "$ac_cxx_werror_flag"
4023                          || test ! -s conftest.err'
4024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4025   (eval $ac_try) 2>&5
4026   ac_status=$?
4027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4028   (exit $ac_status); }; } &&
4029          { ac_try='test -s conftest.$ac_objext'
4030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4031   (eval $ac_try) 2>&5
4032   ac_status=$?
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); }; }; then
4035   ac_compiler_gnu=yes
4036 else
4037   echo "$as_me: failed program was:" >&5
4038 sed 's/^/| /' conftest.$ac_ext >&5
4039
4040 ac_compiler_gnu=no
4041 fi
4042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4043 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4044
4045 fi
4046 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4047 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4048 GXX=`test $ac_compiler_gnu = yes && echo yes`
4049 ac_test_CXXFLAGS=${CXXFLAGS+set}
4050 ac_save_CXXFLAGS=$CXXFLAGS
4051 CXXFLAGS="-g"
4052 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4053 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4054 if test "${ac_cv_prog_cxx_g+set}" = set; then
4055   echo $ECHO_N "(cached) $ECHO_C" >&6
4056 else
4057   cat >conftest.$ac_ext <<_ACEOF
4058 /* confdefs.h.  */
4059 _ACEOF
4060 cat confdefs.h >>conftest.$ac_ext
4061 cat >>conftest.$ac_ext <<_ACEOF
4062 /* end confdefs.h.  */
4063
4064 int
4065 main ()
4066 {
4067
4068   ;
4069   return 0;
4070 }
4071 _ACEOF
4072 rm -f conftest.$ac_objext
4073 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4074   (eval $ac_compile) 2>conftest.er1
4075   ac_status=$?
4076   grep -v '^ *+' conftest.er1 >conftest.err
4077   rm -f conftest.er1
4078   cat conftest.err >&5
4079   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4080   (exit $ac_status); } &&
4081          { ac_try='test -z "$ac_cxx_werror_flag"
4082                          || test ! -s conftest.err'
4083   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4084   (eval $ac_try) 2>&5
4085   ac_status=$?
4086   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4087   (exit $ac_status); }; } &&
4088          { ac_try='test -s conftest.$ac_objext'
4089   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4090   (eval $ac_try) 2>&5
4091   ac_status=$?
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); }; }; then
4094   ac_cv_prog_cxx_g=yes
4095 else
4096   echo "$as_me: failed program was:" >&5
4097 sed 's/^/| /' conftest.$ac_ext >&5
4098
4099 ac_cv_prog_cxx_g=no
4100 fi
4101 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4102 fi
4103 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4104 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4105 if test "$ac_test_CXXFLAGS" = set; then
4106   CXXFLAGS=$ac_save_CXXFLAGS
4107 elif test $ac_cv_prog_cxx_g = yes; then
4108   if test "$GXX" = yes; then
4109     CXXFLAGS="-g -O2"
4110   else
4111     CXXFLAGS="-g"
4112   fi
4113 else
4114   if test "$GXX" = yes; then
4115     CXXFLAGS="-O2"
4116   else
4117     CXXFLAGS=
4118   fi
4119 fi
4120 for ac_declaration in \
4121    '' \
4122    'extern "C" void std::exit (int) throw (); using std::exit;' \
4123    'extern "C" void std::exit (int); using std::exit;' \
4124    'extern "C" void exit (int) throw ();' \
4125    'extern "C" void exit (int);' \
4126    'void exit (int);'
4127 do
4128   cat >conftest.$ac_ext <<_ACEOF
4129 /* confdefs.h.  */
4130 _ACEOF
4131 cat confdefs.h >>conftest.$ac_ext
4132 cat >>conftest.$ac_ext <<_ACEOF
4133 /* end confdefs.h.  */
4134 $ac_declaration
4135 #include <stdlib.h>
4136 int
4137 main ()
4138 {
4139 exit (42);
4140   ;
4141   return 0;
4142 }
4143 _ACEOF
4144 rm -f conftest.$ac_objext
4145 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4146   (eval $ac_compile) 2>conftest.er1
4147   ac_status=$?
4148   grep -v '^ *+' conftest.er1 >conftest.err
4149   rm -f conftest.er1
4150   cat conftest.err >&5
4151   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4152   (exit $ac_status); } &&
4153          { ac_try='test -z "$ac_cxx_werror_flag"
4154                          || test ! -s conftest.err'
4155   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4156   (eval $ac_try) 2>&5
4157   ac_status=$?
4158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4159   (exit $ac_status); }; } &&
4160          { ac_try='test -s conftest.$ac_objext'
4161   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4162   (eval $ac_try) 2>&5
4163   ac_status=$?
4164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4165   (exit $ac_status); }; }; then
4166   :
4167 else
4168   echo "$as_me: failed program was:" >&5
4169 sed 's/^/| /' conftest.$ac_ext >&5
4170
4171 continue
4172 fi
4173 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4174   cat >conftest.$ac_ext <<_ACEOF
4175 /* confdefs.h.  */
4176 _ACEOF
4177 cat confdefs.h >>conftest.$ac_ext
4178 cat >>conftest.$ac_ext <<_ACEOF
4179 /* end confdefs.h.  */
4180 $ac_declaration
4181 int
4182 main ()
4183 {
4184 exit (42);
4185   ;
4186   return 0;
4187 }
4188 _ACEOF
4189 rm -f conftest.$ac_objext
4190 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4191   (eval $ac_compile) 2>conftest.er1
4192   ac_status=$?
4193   grep -v '^ *+' conftest.er1 >conftest.err
4194   rm -f conftest.er1
4195   cat conftest.err >&5
4196   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4197   (exit $ac_status); } &&
4198          { ac_try='test -z "$ac_cxx_werror_flag"
4199                          || test ! -s conftest.err'
4200   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4201   (eval $ac_try) 2>&5
4202   ac_status=$?
4203   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4204   (exit $ac_status); }; } &&
4205          { ac_try='test -s conftest.$ac_objext'
4206   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4207   (eval $ac_try) 2>&5
4208   ac_status=$?
4209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4210   (exit $ac_status); }; }; then
4211   break
4212 else
4213   echo "$as_me: failed program was:" >&5
4214 sed 's/^/| /' conftest.$ac_ext >&5
4215
4216 fi
4217 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4218 done
4219 rm -f conftest*
4220 if test -n "$ac_declaration"; then
4221   echo '#ifdef __cplusplus' >>confdefs.h
4222   echo $ac_declaration      >>confdefs.h
4223   echo '#endif'             >>confdefs.h
4224 fi
4225
4226 ac_ext=c
4227 ac_cpp='$CPP $CPPFLAGS'
4228 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4229 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4230 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4231
4232
4233 # We must set the default linker to the linker used by gcc for the correct
4234 # operation of libtool.  If LD is not defined and we are using gcc, try to
4235 # set the LD default to the ld used by gcc.
4236 if test -z "$LD"; then
4237   if test "$GCC" = yes; then
4238     case $build in
4239     *-*-mingw*)
4240       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4241     *)
4242       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4243     esac
4244     case $gcc_prog_ld in
4245     # Accept absolute paths.
4246     [\\/]* | [A-Za-z]:[\\/]*)
4247       LD="$gcc_prog_ld" ;;
4248     esac
4249   fi
4250 fi
4251
4252
4253
4254
4255 if test -n "$ac_tool_prefix"; then
4256   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4257 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4258 echo "$as_me:$LINENO: checking for $ac_word" >&5
4259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4260 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4261   echo $ECHO_N "(cached) $ECHO_C" >&6
4262 else
4263   if test -n "$GNATBIND"; then
4264   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4265 else
4266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4267 for as_dir in $PATH
4268 do
4269   IFS=$as_save_IFS
4270   test -z "$as_dir" && as_dir=.
4271   for ac_exec_ext in '' $ac_executable_extensions; do
4272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4273     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4275     break 2
4276   fi
4277 done
4278 done
4279
4280 fi
4281 fi
4282 GNATBIND=$ac_cv_prog_GNATBIND
4283 if test -n "$GNATBIND"; then
4284   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4285 echo "${ECHO_T}$GNATBIND" >&6
4286 else
4287   echo "$as_me:$LINENO: result: no" >&5
4288 echo "${ECHO_T}no" >&6
4289 fi
4290
4291 fi
4292 if test -z "$ac_cv_prog_GNATBIND"; then
4293   ac_ct_GNATBIND=$GNATBIND
4294   # Extract the first word of "gnatbind", so it can be a program name with args.
4295 set dummy gnatbind; ac_word=$2
4296 echo "$as_me:$LINENO: checking for $ac_word" >&5
4297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4298 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4299   echo $ECHO_N "(cached) $ECHO_C" >&6
4300 else
4301   if test -n "$ac_ct_GNATBIND"; then
4302   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4303 else
4304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4305 for as_dir in $PATH
4306 do
4307   IFS=$as_save_IFS
4308   test -z "$as_dir" && as_dir=.
4309   for ac_exec_ext in '' $ac_executable_extensions; do
4310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4311     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4313     break 2
4314   fi
4315 done
4316 done
4317
4318   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4319 fi
4320 fi
4321 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4322 if test -n "$ac_ct_GNATBIND"; then
4323   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4324 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4325 else
4326   echo "$as_me:$LINENO: result: no" >&5
4327 echo "${ECHO_T}no" >&6
4328 fi
4329
4330   GNATBIND=$ac_ct_GNATBIND
4331 else
4332   GNATBIND="$ac_cv_prog_GNATBIND"
4333 fi
4334
4335 if test -n "$ac_tool_prefix"; then
4336   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4337 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4338 echo "$as_me:$LINENO: checking for $ac_word" >&5
4339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4340 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4341   echo $ECHO_N "(cached) $ECHO_C" >&6
4342 else
4343   if test -n "$GNATMAKE"; then
4344   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4345 else
4346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4347 for as_dir in $PATH
4348 do
4349   IFS=$as_save_IFS
4350   test -z "$as_dir" && as_dir=.
4351   for ac_exec_ext in '' $ac_executable_extensions; do
4352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4353     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4355     break 2
4356   fi
4357 done
4358 done
4359
4360 fi
4361 fi
4362 GNATMAKE=$ac_cv_prog_GNATMAKE
4363 if test -n "$GNATMAKE"; then
4364   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4365 echo "${ECHO_T}$GNATMAKE" >&6
4366 else
4367   echo "$as_me:$LINENO: result: no" >&5
4368 echo "${ECHO_T}no" >&6
4369 fi
4370
4371 fi
4372 if test -z "$ac_cv_prog_GNATMAKE"; then
4373   ac_ct_GNATMAKE=$GNATMAKE
4374   # Extract the first word of "gnatmake", so it can be a program name with args.
4375 set dummy gnatmake; ac_word=$2
4376 echo "$as_me:$LINENO: checking for $ac_word" >&5
4377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4378 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4379   echo $ECHO_N "(cached) $ECHO_C" >&6
4380 else
4381   if test -n "$ac_ct_GNATMAKE"; then
4382   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4383 else
4384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4385 for as_dir in $PATH
4386 do
4387   IFS=$as_save_IFS
4388   test -z "$as_dir" && as_dir=.
4389   for ac_exec_ext in '' $ac_executable_extensions; do
4390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4391     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4393     break 2
4394   fi
4395 done
4396 done
4397
4398   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4399 fi
4400 fi
4401 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4402 if test -n "$ac_ct_GNATMAKE"; then
4403   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4404 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4405 else
4406   echo "$as_me:$LINENO: result: no" >&5
4407 echo "${ECHO_T}no" >&6
4408 fi
4409
4410   GNATMAKE=$ac_ct_GNATMAKE
4411 else
4412   GNATMAKE="$ac_cv_prog_GNATMAKE"
4413 fi
4414
4415 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4416 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4417 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4418   echo $ECHO_N "(cached) $ECHO_C" >&6
4419 else
4420   cat >conftest.adb <<EOF
4421 procedure conftest is begin null; end conftest;
4422 EOF
4423 acx_cv_cc_gcc_supports_ada=no
4424 # There is a bug in old released versions of GCC which causes the
4425 # driver to exit successfully when the appropriate language module
4426 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4427 # Therefore we must check for the error message as well as an
4428 # unsuccessful exit.
4429 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4430 # given a .adb file, but produce no object file.  So we must check
4431 # if an object file was really produced to guard against this.
4432 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4433 if test x"$errors" = x && test -f conftest.$ac_objext; then
4434   acx_cv_cc_gcc_supports_ada=yes
4435 fi
4436 rm -f conftest.*
4437 fi
4438 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4439 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4440
4441 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4442   have_gnat=yes
4443 else
4444   have_gnat=no
4445 fi
4446
4447 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4448 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4449 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4450   echo $ECHO_N "(cached) $ECHO_C" >&6
4451 else
4452    echo abfoo >t1
4453   echo cdfoo >t2
4454   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4455   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4456     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4457       :
4458     else
4459       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4460     fi
4461   fi
4462   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4463     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4464       :
4465     else
4466       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4467     fi
4468   fi
4469   rm t1 t2
4470
4471 fi
4472 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4473 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4474 do_compare="$gcc_cv_prog_cmp_skip"
4475
4476
4477
4478 # Check for GMP and MPFR
4479 gmplibs="-lmpfr -lgmp"
4480 gmpinc=
4481 have_gmp=no
4482
4483 # Specify a location for mpfr
4484 # check for this first so it ends up on the link line before gmp.
4485
4486 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4487 if test "${with_mpfr_dir+set}" = set; then
4488   withval="$with_mpfr_dir"
4489   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4490 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4491 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4492 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4493    { (exit 1); exit 1; }; }
4494 fi;
4495
4496
4497 # Check whether --with-mpfr or --without-mpfr was given.
4498 if test "${with_mpfr+set}" = set; then
4499   withval="$with_mpfr"
4500
4501 fi;
4502
4503 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4504 if test "${with_mpfr_include+set}" = set; then
4505   withval="$with_mpfr_include"
4506
4507 fi;
4508
4509 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4510 if test "${with_mpfr_lib+set}" = set; then
4511   withval="$with_mpfr_lib"
4512
4513 fi;
4514
4515 if test "x$with_mpfr" != x; then
4516   gmplibs="-L$with_mpfr/lib $gmplibs"
4517   gmpinc="-I$with_mpfr/include"
4518 fi
4519 if test "x$with_mpfr_include" != x; then
4520   gmpinc="-I$with_mpfr_include"
4521 fi
4522 if test "x$with_mpfr_lib" != x; then
4523   gmplibs="-L$with_mpfr_lib $gmplibs"
4524 fi
4525 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4526   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4527   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4528   # Do not test the mpfr version.  Assume that it is sufficient, since
4529   # it is in the source tree, and the library has not been built yet
4530   # but it would be included on the link line in the version check below
4531   # hence making the test fail.
4532   have_gmp=yes
4533 fi
4534
4535 # Specify a location for gmp
4536
4537 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4538 if test "${with_gmp_dir+set}" = set; then
4539   withval="$with_gmp_dir"
4540   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4541 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4542 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4543 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4544    { (exit 1); exit 1; }; }
4545 fi;
4546
4547
4548 # Check whether --with-gmp or --without-gmp was given.
4549 if test "${with_gmp+set}" = set; then
4550   withval="$with_gmp"
4551
4552 fi;
4553
4554 # Check whether --with-gmp_include or --without-gmp_include was given.
4555 if test "${with_gmp_include+set}" = set; then
4556   withval="$with_gmp_include"
4557
4558 fi;
4559
4560 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4561 if test "${with_gmp_lib+set}" = set; then
4562   withval="$with_gmp_lib"
4563
4564 fi;
4565
4566
4567 if test "x$with_gmp" != x; then
4568   gmplibs="-L$with_gmp/lib $gmplibs"
4569   gmpinc="-I$with_gmp/include $gmpinc"
4570 fi
4571 if test "x$with_gmp_include" != x; then
4572   gmpinc="-I$with_gmp_include $gmpinc"
4573 fi
4574 if test "x$with_gmp_lib" != x; then
4575   gmplibs="-L$with_gmp_lib $gmplibs"
4576 fi
4577 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4578   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4579   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4580   # Do not test the gmp version.  Assume that it is sufficient, since
4581   # it is in the source tree, and the library has not been built yet
4582   # but it would be included on the link line in the version check below
4583   # hence making the test fail.
4584   have_gmp=yes
4585 fi
4586
4587 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4588   have_gmp=yes
4589   saved_CFLAGS="$CFLAGS"
4590   CFLAGS="$CFLAGS $gmpinc"
4591   # Check GMP actually works
4592   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4593 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4594
4595 cat >conftest.$ac_ext <<_ACEOF
4596 /* confdefs.h.  */
4597 _ACEOF
4598 cat confdefs.h >>conftest.$ac_ext
4599 cat >>conftest.$ac_ext <<_ACEOF
4600 /* end confdefs.h.  */
4601 #include "gmp.h"
4602 int
4603 main ()
4604 {
4605
4606   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4607   choke me
4608   #endif
4609
4610   ;
4611   return 0;
4612 }
4613 _ACEOF
4614 rm -f conftest.$ac_objext
4615 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4616   (eval $ac_compile) 2>conftest.er1
4617   ac_status=$?
4618   grep -v '^ *+' conftest.er1 >conftest.err
4619   rm -f conftest.er1
4620   cat conftest.err >&5
4621   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4622   (exit $ac_status); } &&
4623          { ac_try='test -z "$ac_c_werror_flag"
4624                          || test ! -s conftest.err'
4625   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4626   (eval $ac_try) 2>&5
4627   ac_status=$?
4628   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4629   (exit $ac_status); }; } &&
4630          { ac_try='test -s conftest.$ac_objext'
4631   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4632   (eval $ac_try) 2>&5
4633   ac_status=$?
4634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4635   (exit $ac_status); }; }; then
4636   echo "$as_me:$LINENO: result: yes" >&5
4637 echo "${ECHO_T}yes" >&6
4638 else
4639   echo "$as_me: failed program was:" >&5
4640 sed 's/^/| /' conftest.$ac_ext >&5
4641
4642 echo "$as_me:$LINENO: result: no" >&5
4643 echo "${ECHO_T}no" >&6; have_gmp=no
4644 fi
4645 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4646
4647   if test x"$have_gmp" = xyes; then
4648     saved_LIBS="$LIBS"
4649     LIBS="$LIBS $gmplibs"
4650         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4651 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4652     cat >conftest.$ac_ext <<_ACEOF
4653 /* confdefs.h.  */
4654 _ACEOF
4655 cat confdefs.h >>conftest.$ac_ext
4656 cat >>conftest.$ac_ext <<_ACEOF
4657 /* end confdefs.h.  */
4658 #include <gmp.h>
4659     #include <mpfr.h>
4660 int
4661 main ()
4662 {
4663
4664     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4665     choke me
4666     #endif
4667     mpfr_t n;
4668     mpfr_t x;
4669     int t;
4670     mpfr_init (n);
4671     mpfr_init (x);
4672     mpfr_atan2 (n, n, x, GMP_RNDN);
4673     mpfr_erfc (n, x, GMP_RNDN);
4674     mpfr_subnormalize (x, t, GMP_RNDN);
4675
4676   ;
4677   return 0;
4678 }
4679 _ACEOF
4680 rm -f conftest.$ac_objext conftest$ac_exeext
4681 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4682   (eval $ac_link) 2>conftest.er1
4683   ac_status=$?
4684   grep -v '^ *+' conftest.er1 >conftest.err
4685   rm -f conftest.er1
4686   cat conftest.err >&5
4687   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4688   (exit $ac_status); } &&
4689          { ac_try='test -z "$ac_c_werror_flag"
4690                          || test ! -s conftest.err'
4691   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4692   (eval $ac_try) 2>&5
4693   ac_status=$?
4694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4695   (exit $ac_status); }; } &&
4696          { ac_try='test -s conftest$ac_exeext'
4697   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4698   (eval $ac_try) 2>&5
4699   ac_status=$?
4700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4701   (exit $ac_status); }; }; then
4702   cat >conftest.$ac_ext <<_ACEOF
4703 /* confdefs.h.  */
4704 _ACEOF
4705 cat confdefs.h >>conftest.$ac_ext
4706 cat >>conftest.$ac_ext <<_ACEOF
4707 /* end confdefs.h.  */
4708 #include <gmp.h>
4709     #include <mpfr.h>
4710 int
4711 main ()
4712 {
4713
4714     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4715     choke me
4716     #endif
4717     mpfr_t n; mpfr_init(n);
4718
4719   ;
4720   return 0;
4721 }
4722 _ACEOF
4723 rm -f conftest.$ac_objext conftest$ac_exeext
4724 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4725   (eval $ac_link) 2>conftest.er1
4726   ac_status=$?
4727   grep -v '^ *+' conftest.er1 >conftest.err
4728   rm -f conftest.er1
4729   cat conftest.err >&5
4730   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4731   (exit $ac_status); } &&
4732          { ac_try='test -z "$ac_c_werror_flag"
4733                          || test ! -s conftest.err'
4734   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4735   (eval $ac_try) 2>&5
4736   ac_status=$?
4737   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4738   (exit $ac_status); }; } &&
4739          { ac_try='test -s conftest$ac_exeext'
4740   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4741   (eval $ac_try) 2>&5
4742   ac_status=$?
4743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4744   (exit $ac_status); }; }; then
4745   echo "$as_me:$LINENO: result: yes" >&5
4746 echo "${ECHO_T}yes" >&6
4747 else
4748   echo "$as_me: failed program was:" >&5
4749 sed 's/^/| /' conftest.$ac_ext >&5
4750
4751 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4752 echo "${ECHO_T}buggy but acceptable" >&6
4753 fi
4754 rm -f conftest.err conftest.$ac_objext \
4755       conftest$ac_exeext conftest.$ac_ext
4756 else
4757   echo "$as_me: failed program was:" >&5
4758 sed 's/^/| /' conftest.$ac_ext >&5
4759
4760 echo "$as_me:$LINENO: result: no" >&5
4761 echo "${ECHO_T}no" >&6; have_gmp=no
4762 fi
4763 rm -f conftest.err conftest.$ac_objext \
4764       conftest$ac_exeext conftest.$ac_ext
4765       LIBS="$saved_LIBS"
4766   fi
4767   CFLAGS="$saved_CFLAGS"
4768
4769   if test x$have_gmp != xyes; then
4770     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4771 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4772 Copies of these libraries' source code can be found at their respective
4773 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4774 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4775 If you obtained GMP and/or MPFR from a vendor distribution package, make
4776 sure that you have installed both the libraries and the header files.
4777 They may be located in separate packages." >&5
4778 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4779 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4780 Copies of these libraries' source code can be found at their respective
4781 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4782 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4783 If you obtained GMP and/or MPFR from a vendor distribution package, make
4784 sure that you have installed both the libraries and the header files.
4785 They may be located in separate packages." >&2;}
4786    { (exit 1); exit 1; }; }
4787   fi
4788 fi
4789
4790 # Flags needed for both GMP and/or MPFR
4791
4792
4793
4794 # By default, C is the only stage 1 language.
4795 stage1_languages=,c,
4796
4797 # Figure out what language subdirectories are present.
4798 # Look if the user specified --enable-languages="..."; if not, use
4799 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4800 # go away some day.
4801 # NB:  embedded tabs in this IF block -- do not untabify
4802 if test -d ${srcdir}/gcc; then
4803   if test x"${enable_languages+set}" != xset; then
4804     if test x"${LANGUAGES+set}" = xset; then
4805       enable_languages="${LANGUAGES}"
4806         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4807     else
4808       enable_languages=all
4809     fi
4810   else
4811     if test x"${enable_languages}" = x ||
4812        test x"${enable_languages}" = xyes;
4813        then
4814       echo configure.in: --enable-languages needs at least one language argument 1>&2
4815       exit 1
4816     fi
4817   fi
4818   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4819
4820   # 'f95' is the old name for the 'fortran' language. We issue a warning
4821   # and make the substitution.
4822   case ,${enable_languages}, in
4823     *,f95,*)
4824       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4825       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4826       ;;
4827   esac
4828
4829   # First scan to see if an enabled language requires some other language.
4830   # We assume that a given config-lang.in will list all the language
4831   # front ends it requires, even if some are required indirectly.
4832   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4833     case ${lang_frag} in
4834       ..) ;;
4835       # The odd quoting in the next line works around
4836       # an apparent bug in bash 1.12 on linux.
4837       ${srcdir}/gcc/[*]/config-lang.in) ;;
4838       *)
4839         # From the config-lang.in, get $language, $lang_requires
4840         language=
4841         lang_requires=
4842         . ${lang_frag}
4843         for other in ${lang_requires} ; do
4844           case ,${enable_languages}, in
4845             *,$other,*) ;;
4846             *,all,*) ;;
4847             *,$language,*)
4848               echo " \`$other' language required by \`$language'; enabling" 1>&2
4849               enable_languages="${enable_languages},${other}"
4850               ;;
4851           esac
4852         done
4853         ;;
4854     esac
4855   done
4856
4857   new_enable_languages=,c,
4858   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4859   potential_languages=,c,
4860
4861   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4862     case ${lang_frag} in
4863       ..) ;;
4864       # The odd quoting in the next line works around
4865       # an apparent bug in bash 1.12 on linux.
4866       ${srcdir}/gcc/[*]/config-lang.in) ;;
4867       *)
4868         # From the config-lang.in, get $language, $target_libs,
4869         # $lang_dirs, $boot_language, and $build_by_default
4870         language=
4871         target_libs=
4872         lang_dirs=
4873         subdir_requires=
4874         boot_language=no
4875         build_by_default=yes
4876         . ${lang_frag}
4877         if test x${language} = x; then
4878           echo "${lang_frag} doesn't set \$language." 1>&2
4879           exit 1
4880         fi
4881
4882         case ,${enable_languages}, in
4883           *,${language},*)
4884             # Language was explicitly selected; include it.
4885             add_this_lang=yes
4886             ;;
4887           *,all,*)
4888             # 'all' was selected, select it if it is a default language
4889             add_this_lang=${build_by_default}
4890             ;;
4891           *)
4892             add_this_lang=no
4893             ;;
4894         esac
4895
4896         # Disable languages that need other directories if these aren't available.
4897         for i in $subdir_requires; do
4898           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4899           case ,${enable_languages}, in
4900             *,${language},*)
4901               # Specifically requested language; tell them.
4902               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4903 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4904    { (exit 1); exit 1; }; }
4905               ;;
4906             *)
4907               # Silently disable.
4908               add_this_lang=unsupported
4909               ;;
4910           esac
4911         done
4912
4913         # Disable Ada if no preexisting GNAT is available.
4914         case ,${enable_languages},:${language}:${have_gnat} in
4915           *,${language},*:ada:no)
4916             # Specifically requested language; tell them.
4917             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4918 echo "$as_me: error: GNAT is required to build $language" >&2;}
4919    { (exit 1); exit 1; }; }
4920             ;;
4921           *:ada:no)
4922             # Silently disable.
4923             add_this_lang=unsupported
4924             ;;
4925         esac
4926
4927         # Disable a language that is unsupported by the target.
4928         case " $unsupported_languages " in
4929           *" $language "*)
4930             add_this_lang=unsupported
4931             ;;
4932         esac
4933
4934         case $add_this_lang in
4935           unsupported)
4936             # Remove language-dependent dirs.
4937             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4938             ;;
4939           no)
4940             # Remove language-dependent dirs; still show language as supported.
4941             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4942             potential_languages="${potential_languages}${language},"
4943             ;;
4944           yes)
4945             new_enable_languages="${new_enable_languages}${language},"
4946             potential_languages="${potential_languages}${language},"
4947             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4948             case ${boot_language} in
4949               yes)
4950                 # Add to (comma-separated) list of stage 1 languages.
4951                 stage1_languages="${stage1_languages}${language},"
4952                 ;;
4953             esac
4954             ;;
4955         esac
4956         ;;
4957     esac
4958   done
4959
4960   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4961 if test "${enable_stage1_languages+set}" = set; then
4962   enableval="$enable_stage1_languages"
4963   case ,${enable_stage1_languages}, in
4964     ,no,|,,)
4965       # Set it to something that will have no effect in the loop below
4966       enable_stage1_languages=c ;;
4967     ,yes,)
4968       enable_stage1_languages=`echo $new_enable_languages | \
4969         sed -e "s/^,//" -e "s/,$//" ` ;;
4970     *,all,*)
4971       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4972         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4973   esac
4974
4975   # Add "good" languages from enable_stage1_languages to stage1_languages,
4976   # while "bad" languages go in missing_languages.  Leave no duplicates.
4977   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4978     case $potential_languages in
4979       *,$i,*)
4980         case $stage1_languages in
4981           *,$i,*) ;;
4982           *) stage1_languages="$stage1_languages$i," ;;
4983         esac ;;
4984       *)
4985         case $missing_languages in
4986           *,$i,*) ;;
4987           *) missing_languages="$missing_languages$i," ;;
4988         esac ;;
4989      esac
4990   done
4991 fi;
4992
4993   # Remove leading/trailing commas that were added for simplicity
4994   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4995   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4996   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4997   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4998
4999   if test "x$missing_languages" != x; then
5000     { { echo "$as_me:$LINENO: error:
5001 The following requested languages could not be built: ${missing_languages}
5002 Supported languages are: ${potential_languages}" >&5
5003 echo "$as_me: error:
5004 The following requested languages could not be built: ${missing_languages}
5005 Supported languages are: ${potential_languages}" >&2;}
5006    { (exit 1); exit 1; }; }
5007   fi
5008   if test "x$new_enable_languages" != "x$enable_languages"; then
5009     echo The following languages will be built: ${new_enable_languages}
5010     enable_languages="$new_enable_languages"
5011   fi
5012
5013
5014   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5015 fi
5016
5017 # Handle --disable-<component> generically.
5018 for dir in $configdirs $build_configdirs $target_configdirs ; do
5019   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5020   varname=`echo $dirname | sed -e s/+/_/g`
5021   if eval test x\${enable_${varname}} "=" xno ; then
5022     noconfigdirs="$noconfigdirs $dir"
5023   fi
5024 done
5025
5026 # Check for Boehm's garbage collector
5027 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5028 if test "${enable_objc_gc+set}" = set; then
5029   enableval="$enable_objc_gc"
5030   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5031   *,objc,*:*:yes:*target-boehm-gc*)
5032     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5033 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5034    { (exit 1); exit 1; }; }
5035     ;;
5036 esac
5037 fi;
5038
5039 # Make sure we only build Boehm's garbage collector if required.
5040 case ,${enable_languages},:${enable_objc_gc} in
5041   *,objc,*:yes)
5042     # Keep target-boehm-gc if requested for Objective-C.
5043     ;;
5044   *)
5045     # Otherwise remove target-boehm-gc depending on target-libjava.
5046     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5047       noconfigdirs="$noconfigdirs target-boehm-gc"
5048     fi
5049     ;;
5050 esac
5051
5052 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5053 # $build_configdirs and $target_configdirs.
5054 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5055
5056 notsupp=""
5057 for dir in . $skipdirs $noconfigdirs ; do
5058   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5059   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5060     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5061     if test -r $srcdir/$dirname/configure ; then
5062       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5063         true
5064       else
5065         notsupp="$notsupp $dir"
5066       fi
5067     fi
5068   fi
5069   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5070     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5071     if test -r $srcdir/$dirname/configure ; then
5072       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5073         true
5074       else
5075         notsupp="$notsupp $dir"
5076       fi
5077     fi
5078   fi
5079   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5080     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5081     if test -r $srcdir/$dirname/configure ; then
5082       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5083         true
5084       else
5085         notsupp="$notsupp $dir"
5086       fi
5087     fi
5088   fi
5089 done
5090
5091 # Sometimes the tools are distributed with libiberty but with no other
5092 # libraries.  In that case, we don't want to build target-libiberty.
5093 # Don't let libgcc imply libiberty either.
5094 if test -n "${target_configdirs}" ; then
5095   libgcc=
5096   others=
5097   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5098     if test "$i" = "libgcc"; then
5099       libgcc=target-libgcc
5100     elif test "$i" != "libiberty" ; then
5101       if test -r $srcdir/$i/configure ; then
5102         others=yes;
5103         break;
5104       fi
5105     fi
5106   done
5107   if test -z "${others}" ; then
5108     target_configdirs=$libgcc
5109   fi
5110 fi
5111
5112 # Quietly strip out all directories which aren't configurable in this tree.
5113 # This relies on all configurable subdirectories being autoconfiscated, which
5114 # is now the case.
5115 build_configdirs_all="$build_configdirs"
5116 build_configdirs=
5117 for i in ${build_configdirs_all} ; do
5118   j=`echo $i | sed -e s/build-//g`
5119   if test -f ${srcdir}/$j/configure ; then
5120     build_configdirs="${build_configdirs} $i"
5121   fi
5122 done
5123
5124 configdirs_all="$configdirs"
5125 configdirs=
5126 for i in ${configdirs_all} ; do
5127   if test -f ${srcdir}/$i/configure ; then
5128     configdirs="${configdirs} $i"
5129   fi
5130 done
5131
5132 target_configdirs_all="$target_configdirs"
5133 target_configdirs=
5134 for i in ${target_configdirs_all} ; do
5135   j=`echo $i | sed -e s/target-//g`
5136   if test -f ${srcdir}/$j/configure ; then
5137     target_configdirs="${target_configdirs} $i"
5138   fi
5139 done
5140
5141 # Produce a warning message for the subdirs we can't configure.
5142 # This isn't especially interesting in the Cygnus tree, but in the individual
5143 # FSF releases, it's important to let people know when their machine isn't
5144 # supported by the one or two programs in a package.
5145
5146 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5147   # If $appdirs is non-empty, at least one of those directories must still
5148   # be configured, or we error out.  (E.g., if the gas release supports a
5149   # specified target in some subdirs but not the gas subdir, we shouldn't
5150   # pretend that all is well.)
5151   if test -n "$appdirs" ; then
5152     for dir in $appdirs ; do
5153       if test -r $dir/Makefile.in ; then
5154         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5155           appdirs=""
5156           break
5157         fi
5158         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5159           appdirs=""
5160           break
5161         fi
5162       fi
5163     done
5164     if test -n "$appdirs" ; then
5165       echo "*** This configuration is not supported by this package." 1>&2
5166       exit 1
5167     fi
5168   fi
5169   # Okay, some application will build, or we don't care to check.  Still
5170   # notify of subdirs not getting built.
5171   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5172   echo "    ${notsupp}" 1>&2
5173   echo "    (Any other directories should still work fine.)" 1>&2
5174 fi
5175
5176 case "$host" in
5177   *msdosdjgpp*)
5178     enable_gdbtk=no ;;
5179 esac
5180
5181 # To find our prefix, in gcc_cv_tool_prefix.
5182
5183 # The user is always right.
5184 if test "${PATH_SEPARATOR+set}" != set; then
5185   echo "#! /bin/sh" >conf$$.sh
5186   echo  "exit 0"   >>conf$$.sh
5187   chmod +x conf$$.sh
5188   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5189     PATH_SEPARATOR=';'
5190   else
5191     PATH_SEPARATOR=:
5192   fi
5193   rm -f conf$$.sh
5194 fi
5195
5196
5197
5198 if test "x$exec_prefix" = xNONE; then
5199         if test "x$prefix" = xNONE; then
5200                 gcc_cv_tool_prefix=$ac_default_prefix
5201         else
5202                 gcc_cv_tool_prefix=$prefix
5203         fi
5204 else
5205         gcc_cv_tool_prefix=$exec_prefix
5206 fi
5207
5208 # If there is no compiler in the tree, use the PATH only.  In any
5209 # case, if there is no compiler in the tree nobody should use
5210 # AS_FOR_TARGET and LD_FOR_TARGET.
5211 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5212     gcc_version=`cat $srcdir/gcc/BASE-VER`
5213     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5214     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5215     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5216     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5217     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5218     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5219 else
5220     gcc_cv_tool_dirs=
5221 fi
5222
5223 if test x$build = x$target && test -n "$md_exec_prefix"; then
5224         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5225 fi
5226
5227
5228
5229 copy_dirs=
5230
5231
5232 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5233 if test "${with_build_sysroot+set}" = set; then
5234   withval="$with_build_sysroot"
5235   if test x"$withval" != x ; then
5236      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5237    fi
5238 else
5239   SYSROOT_CFLAGS_FOR_TARGET=
5240 fi;
5241
5242
5243
5244 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5245 if test "${with_debug_prefix_map+set}" = set; then
5246   withval="$with_debug_prefix_map"
5247   if test x"$withval" != x; then
5248      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5249      for debug_map in $withval; do
5250        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5251      done
5252    fi
5253 else
5254   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5255 fi;
5256
5257
5258 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5259 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5260 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5261 # We want to ensure that TARGET libraries (which we know are built with
5262 # gcc) are built with "-O2 -g", so include those options when setting
5263 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5264 if test "x$CFLAGS_FOR_TARGET" = x; then
5265   CFLAGS_FOR_TARGET=$CFLAGS
5266   case " $CFLAGS " in
5267     *" -O2 "*) ;;
5268     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5269   esac
5270   case " $CFLAGS " in
5271     *" -g "* | *" -g3 "*) ;;
5272     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5273   esac
5274 fi
5275
5276
5277 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5278   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5279   case " $CXXFLAGS " in
5280     *" -O2 "*) ;;
5281     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5282   esac
5283   case " $CXXFLAGS " in
5284     *" -g "* | *" -g3 "*) ;;
5285     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5286   esac
5287 fi
5288
5289
5290 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5291 # the named directory are copied to $(tooldir)/sys-include.
5292 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5293   if test x${is_cross_compiler} = xno ; then
5294     echo 1>&2 '***' --with-headers is only supported when cross compiling
5295     exit 1
5296   fi
5297   if test x"${with_headers}" != xyes ; then
5298     x=${gcc_cv_tool_prefix}
5299     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5300   fi
5301 fi
5302
5303 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5304 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5305 # are permitted.
5306 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5307   if test x${is_cross_compiler} = xno ; then
5308     echo 1>&2 '***' --with-libs is only supported when cross compiling
5309     exit 1
5310   fi
5311   if test x"${with_libs}" != xyes ; then
5312     # Copy the libraries in reverse order, so that files in the first named
5313     # library override files in subsequent libraries.
5314     x=${gcc_cv_tool_prefix}
5315     for l in ${with_libs}; do
5316       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5317     done
5318   fi
5319 fi
5320
5321 # Set with_gnu_as and with_gnu_ld as appropriate.
5322 #
5323 # This is done by determining whether or not the appropriate directory
5324 # is available, and by checking whether or not specific configurations
5325 # have requested that this magic not happen.
5326 #
5327 # The command line options always override the explicit settings in
5328 # configure.in, and the settings in configure.in override this magic.
5329 #
5330 # If the default for a toolchain is to use GNU as and ld, and you don't
5331 # want to do that, then you should use the --without-gnu-as and
5332 # --without-gnu-ld options for the configure script.
5333
5334 if test x${use_gnu_as} = x &&
5335    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5336   with_gnu_as=yes
5337   extra_host_args="$extra_host_args --with-gnu-as"
5338 fi
5339
5340 if test x${use_gnu_ld} = x &&
5341    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5342   with_gnu_ld=yes
5343   extra_host_args="$extra_host_args --with-gnu-ld"
5344 fi
5345
5346 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5347 # can detect this case.
5348
5349 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5350   with_newlib=yes
5351   extra_host_args="$extra_host_args --with-newlib"
5352 fi
5353
5354 # Handle ${copy_dirs}
5355 set fnord ${copy_dirs}
5356 shift
5357 while test $# != 0 ; do
5358   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5359     :
5360   else
5361     echo Copying $1 to $2
5362
5363     # Use the install script to create the directory and all required
5364     # parent directories.
5365     if test -d $2 ; then
5366       :
5367     else
5368       echo >config.temp
5369       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5370     fi
5371
5372     # Copy the directory, assuming we have tar.
5373     # FIXME: Should we use B in the second tar?  Not all systems support it.
5374     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5375
5376     # It is the responsibility of the user to correctly adjust all
5377     # symlinks.  If somebody can figure out how to handle them correctly
5378     # here, feel free to add the code.
5379
5380     echo $1 > $2/COPIED
5381   fi
5382   shift; shift
5383 done
5384
5385 # Determine a target-dependent exec_prefix that the installed
5386 # gcc will search in.  Keep this list sorted by triplet, with
5387 # the *-*-osname triplets last.
5388 md_exec_prefix=
5389 case "${target}" in
5390   alpha*-*-*vms*)
5391     md_exec_prefix=/gnu/lib/gcc-lib
5392     ;;
5393   i[34567]86-pc-msdosdjgpp*)
5394     md_exec_prefix=/dev/env/DJDIR/bin
5395     ;;
5396   i[34567]86-*-sco3.2v5*)
5397     if test $with_gnu_as = yes; then
5398       md_exec_prefix=/usr/gnu/bin
5399     else
5400       md_exec_prefix=/usr/ccs/bin/elf
5401     fi
5402     ;;
5403
5404   mn10300-*-* | \
5405   powerpc-*-chorusos* | \
5406   powerpc*-*-eabi* | \
5407   powerpc*-*-sysv* | \
5408   powerpc*-*-kaos* | \
5409   s390x-ibm-tpf*)
5410     md_exec_prefix=/usr/ccs/bin
5411     ;;
5412   sparc64-*-elf*)
5413     ;;
5414   v850*-*-*)
5415     md_exec_prefix=/usr/ccs/bin
5416     ;;
5417   xtensa*-*-elf*)
5418     ;;
5419
5420   *-*-beos* | \
5421   *-*-elf* | \
5422   *-*-hpux* | \
5423   *-*-netware* | \
5424   *-*-nto-qnx* | \
5425   *-*-rtems* | \
5426   *-*-solaris2* | \
5427   *-*-sysv[45]* | \
5428   *-*-vxworks* | \
5429   *-wrs-windiss)
5430     md_exec_prefix=/usr/ccs/bin
5431     ;;
5432 esac
5433
5434 extra_arflags_for_target=
5435 extra_nmflags_for_target=
5436 extra_ranlibflags_for_target=
5437 target_makefile_frag=/dev/null
5438 case "${target}" in
5439   mep*-*-*)
5440     target_makefile_frag="config/mt-mep"
5441     ;;
5442   spu-*-*)
5443     target_makefile_frag="config/mt-spu"
5444     ;;
5445   mips*-sde-elf*)
5446     target_makefile_frag="config/mt-sde"
5447     ;;
5448   mipsisa*-*-elfoabi*)
5449     target_makefile_frag="config/mt-mips-elfoabi"
5450     ;;
5451   *-*-netware*)
5452     target_makefile_frag="config/mt-netware"
5453     ;;
5454   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5455     target_makefile_frag="config/mt-gnu"
5456     ;;
5457   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5458     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5459     # commands to handle both 32-bit and 64-bit objects.  These flags are
5460     # harmless if we're using GNU nm or ar.
5461     extra_arflags_for_target=" -X32_64"
5462     extra_nmflags_for_target=" -B -X32_64"
5463     ;;
5464   *-*-darwin*)
5465     # ranlib from Darwin requires the -c flag to look at common symbols.
5466     extra_ranlibflags_for_target=" -c"
5467     ;;
5468   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5469     target_makefile_frag="config/mt-wince"
5470     ;;
5471 esac
5472
5473 alphaieee_frag=/dev/null
5474 case $target in
5475   alpha*-*-*)
5476     # This just makes sure to use the -mieee option to build target libs.
5477     # This should probably be set individually by each library.
5478     alphaieee_frag="config/mt-alphaieee"
5479     ;;
5480 esac
5481
5482 # If --enable-target-optspace always use -Os instead of -O2 to build
5483 # the target libraries, similarly if it is not specified, use -Os
5484 # on selected platforms.
5485 ospace_frag=/dev/null
5486 case "${enable_target_optspace}:${target}" in
5487   yes:*)
5488     ospace_frag="config/mt-ospace"
5489     ;;
5490   :d30v-*)
5491     ospace_frag="config/mt-d30v"
5492     ;;
5493   :m32r-* | :d10v-* | :fr30-*)
5494     ospace_frag="config/mt-ospace"
5495     ;;
5496   no:* | :*)
5497     ;;
5498   *)
5499     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5500     ;;
5501 esac
5502
5503 # Default to using --with-stabs for certain targets.
5504 if test x${with_stabs} = x ; then
5505   case "${target}" in
5506   mips*-*-irix[56]*)
5507     ;;
5508   mips*-*-* | alpha*-*-osf*)
5509     with_stabs=yes;
5510     extra_host_args="${extra_host_args} --with-stabs"
5511     ;;
5512   esac
5513 fi
5514
5515 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5516 # them automatically.
5517 case "${host}" in
5518   hppa*64*-*-hpux11*)
5519     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5520     ;;
5521 esac
5522
5523 # Some systems (e.g., one of the i386-aix systems the gas testers are
5524 # using) don't handle "\$" correctly, so don't use it here.
5525 tooldir='${exec_prefix}'/${target_noncanonical}
5526 build_tooldir=${tooldir}
5527
5528 # Create a .gdbinit file which runs the one in srcdir
5529 # and tells GDB to look there for source files.
5530
5531 if test -r ${srcdir}/.gdbinit ; then
5532   case ${srcdir} in
5533     .) ;;
5534     *) cat > ./.gdbinit <<EOF
5535 # ${NO_EDIT}
5536 dir ${srcdir}
5537 dir .
5538 source ${srcdir}/.gdbinit
5539 EOF
5540     ;;
5541   esac
5542 fi
5543
5544 # Make sure that the compiler is able to generate an executable.  If it
5545 # can't, we are probably in trouble.  We don't care whether we can run the
5546 # executable--we might be using a cross compiler--we only care whether it
5547 # can be created.  At this point the main configure script has set CC.
5548 we_are_ok=no
5549 echo "int main () { return 0; }" > conftest.c
5550 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5551 if test $? = 0 ; then
5552   if test -s conftest || test -s conftest.exe ; then
5553     we_are_ok=yes
5554   fi
5555 fi
5556 case $we_are_ok in
5557   no)
5558     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5559     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5560     rm -f conftest*
5561     exit 1
5562     ;;
5563 esac
5564 rm -f conftest*
5565
5566 # The Solaris /usr/ucb/cc compiler does not appear to work.
5567 case "${host}" in
5568   sparc-sun-solaris2*)
5569       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5570       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5571           could_use=
5572           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5573           if test -d /opt/cygnus/bin ; then
5574               if test "$could_use" = "" ; then
5575                   could_use="/opt/cygnus/bin"
5576               else
5577                   could_use="$could_use or /opt/cygnus/bin"
5578               fi
5579           fi
5580         if test "$could_use" = "" ; then
5581             echo "Warning: compilation may fail because you're using"
5582             echo "/usr/ucb/cc.  You should change your PATH or CC "
5583             echo "variable and rerun configure."
5584         else
5585             echo "Warning: compilation may fail because you're using"
5586             echo "/usr/ucb/cc, when you should use the C compiler from"
5587             echo "$could_use.  You should change your"
5588             echo "PATH or CC variable and rerun configure."
5589         fi
5590       fi
5591   ;;
5592 esac
5593
5594 case "${host}" in
5595   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5596   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5597   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5598 esac
5599
5600 # Record target_configdirs and the configure arguments for target and
5601 # build configuration in Makefile.
5602 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5603 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5604
5605 # Determine whether gdb needs tk/tcl or not.
5606 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5607 # and in that case we want gdb to be built without tk.  Ugh!
5608 # In fact I believe gdb is the *only* package directly dependent on tk,
5609 # so we should be able to put the 'maybe's in unconditionally and
5610 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5611 # 100% sure that that's safe though.
5612
5613 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5614 case "$enable_gdbtk" in
5615   no)
5616     GDB_TK="" ;;
5617   yes)
5618     GDB_TK="${gdb_tk}" ;;
5619   *)
5620     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5621     # distro.  Eventually someone will fix this and move Insight, nee
5622     # gdbtk to a separate directory.
5623     if test -d ${srcdir}/gdb/gdbtk ; then
5624       GDB_TK="${gdb_tk}"
5625     else
5626       GDB_TK=""
5627     fi
5628     ;;
5629 esac
5630 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5631 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5632
5633 # Strip out unwanted targets.
5634
5635 # While at that, we remove Makefiles if we were started for recursive
5636 # configuration, so that the top-level Makefile reconfigures them,
5637 # like we used to do when configure itself was recursive.
5638
5639 # Loop over modules.  $extrasub must be used with care, limiting as
5640 # much as possible the usage of range addresses.  That's because autoconf
5641 # splits the sed script to overcome limits in the number of commands,
5642 # and relying on carefully-timed sed passes may turn out to be very hard
5643 # to maintain later.  In this particular case, you just have to be careful
5644 # not to nest @if/@endif pairs, because configure will not warn you at all.
5645
5646 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5647 if test "${enable_bootstrap+set}" = set; then
5648   enableval="$enable_bootstrap"
5649
5650 else
5651   enable_bootstrap=default
5652 fi;
5653
5654 # Issue errors and warnings for invalid/strange bootstrap combinations.
5655 case "$configdirs" in
5656   *gcc*) have_compiler=yes ;;
5657   *) have_compiler=no ;;
5658 esac
5659
5660 case "$have_compiler:$host:$target:$enable_bootstrap" in
5661   *:*:*:no) ;;
5662
5663   # Default behavior.  Enable bootstrap if we have a compiler
5664   # and we are in a native configuration.
5665   yes:$build:$build:default)
5666     enable_bootstrap=yes ;;
5667
5668   *:*:*:default)
5669     enable_bootstrap=no ;;
5670
5671   # We have a compiler and we are in a native configuration, bootstrap is ok
5672   yes:$build:$build:yes)
5673     ;;
5674
5675   # Other configurations, but we have a compiler.  Assume the user knows
5676   # what he's doing.
5677   yes:*:*:yes)
5678     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5679 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5680     ;;
5681
5682   # No compiler: if they passed --enable-bootstrap explicitly, fail
5683   no:*:*:yes)
5684     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5685 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5686    { (exit 1); exit 1; }; } ;;
5687
5688   # Fail if wrong command line
5689   *)
5690     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5691 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5692    { (exit 1); exit 1; }; }
5693     ;;
5694 esac
5695
5696 # Adjust the toplevel makefile according to whether bootstrap was selected.
5697 case "$enable_bootstrap" in
5698   yes)
5699     bootstrap_suffix=bootstrap ;;
5700   no)
5701     bootstrap_suffix=no-bootstrap ;;
5702 esac
5703
5704 for module in ${build_configdirs} ; do
5705   if test -z "${no_recursion}" \
5706      && test -f ${build_subdir}/${module}/Makefile; then
5707     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5708     rm -f ${build_subdir}/${module}/Makefile
5709   fi
5710   extrasub="$extrasub
5711 /^@if build-$module\$/d
5712 /^@endif build-$module\$/d
5713 /^@if build-$module-$bootstrap_suffix\$/d
5714 /^@endif build-$module-$bootstrap_suffix\$/d"
5715 done
5716 for module in ${configdirs} ; do
5717   if test -z "${no_recursion}"; then
5718     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5719       if test -f ${file}; then
5720         echo 1>&2 "*** removing ${file} to force reconfigure"
5721         rm -f ${file}
5722       fi
5723     done
5724   fi
5725   extrasub="$extrasub
5726 /^@if $module\$/d
5727 /^@endif $module\$/d
5728 /^@if $module-$bootstrap_suffix\$/d
5729 /^@endif $module-$bootstrap_suffix\$/d"
5730 done
5731 for module in ${target_configdirs} ; do
5732   if test -z "${no_recursion}" \
5733      && test -f ${target_subdir}/${module}/Makefile; then
5734     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5735     rm -f ${target_subdir}/${module}/Makefile
5736   fi
5737   extrasub="$extrasub
5738 /^@if target-$module\$/d
5739 /^@endif target-$module\$/d
5740 /^@if target-$module-$bootstrap_suffix\$/d
5741 /^@endif target-$module-$bootstrap_suffix\$/d"
5742 done
5743
5744 extrasub="$extrasub
5745 /^@if /,/^@endif /d"
5746
5747 # Create the serialization dependencies.  This uses a temporary file.
5748
5749 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5750 if test "${enable_serial_configure+set}" = set; then
5751   enableval="$enable_serial_configure"
5752
5753 fi;
5754
5755 case ${enable_serial_configure} in
5756   yes)
5757     enable_serial_build_configure=yes
5758     enable_serial_host_configure=yes
5759     enable_serial_target_configure=yes
5760     ;;
5761 esac
5762
5763 # These force 'configure's to be done one at a time, to avoid problems
5764 # with contention over a shared config.cache.
5765 rm -f serdep.tmp
5766 echo '# serdep.tmp' > serdep.tmp
5767 olditem=
5768 test "x${enable_serial_build_configure}" = xyes &&
5769 for item in ${build_configdirs} ; do
5770   case ${olditem} in
5771     "") ;;
5772     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5773   esac
5774   olditem=${item}
5775 done
5776 olditem=
5777 test "x${enable_serial_host_configure}" = xyes &&
5778 for item in ${configdirs} ; do
5779   case ${olditem} in
5780     "") ;;
5781     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5782   esac
5783   olditem=${item}
5784 done
5785 olditem=
5786 test "x${enable_serial_target_configure}" = xyes &&
5787 for item in ${target_configdirs} ; do
5788   case ${olditem} in
5789     "") ;;
5790     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5791   esac
5792   olditem=${item}
5793 done
5794 serialization_dependencies=serdep.tmp
5795
5796
5797 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5798 # target, nonopt, and variable assignments.  These are the ones we
5799 # might not want to pass down to subconfigures.  Also strip
5800 # program-prefix, program-suffix, and program-transform-name, so that
5801 # we can pass down a consistent program-transform-name.
5802 baseargs=
5803 keep_next=no
5804 skip_next=no
5805 eval "set -- $ac_configure_args"
5806 for ac_arg
5807 do
5808   if test X"$skip_next" = X"yes"; then
5809     skip_next=no
5810     continue
5811   fi
5812   if test X"$keep_next" = X"yes"; then
5813     case $ac_arg in
5814       *\'*)
5815         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5816     esac
5817     baseargs="$baseargs '$ac_arg'"
5818     keep_next=no
5819     continue
5820   fi
5821
5822   # Handle separated arguments.  Based on the logic generated by
5823   # autoconf 2.59.
5824   case $ac_arg in
5825     *=* | --config-cache | -C | -disable-* | --disable-* \
5826       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5827       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5828       | -with-* | --with-* | -without-* | --without-* | --x)
5829       separate_arg=no
5830       ;;
5831     -*)
5832       separate_arg=yes
5833       ;;
5834     *)
5835       separate_arg=no
5836       ;;
5837   esac
5838
5839   case "$ac_arg" in
5840     --no*)
5841       continue
5842       ;;
5843     --c* | \
5844     --sr* | \
5845     --ho* | \
5846     --bu* | \
5847     --t* | \
5848     --program-* | \
5849     -cache_file* | \
5850     -srcdir* | \
5851     -host* | \
5852     -build* | \
5853     -target* | \
5854     -program-prefix* | \
5855     -program-suffix* | \
5856     -program-transform-name* )
5857       skip_next=$separate_arg
5858       continue
5859       ;;
5860     -*)
5861       # An option.  Add it.
5862       case $ac_arg in
5863         *\'*)
5864           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5865       esac
5866       baseargs="$baseargs '$ac_arg'"
5867       keep_next=$separate_arg
5868       ;;
5869     *)
5870       # Either a variable assignment, or a nonopt (triplet).  Don't
5871       # pass it down; let the Makefile handle this.
5872       continue
5873       ;;
5874   esac
5875 done
5876 # Remove the initial space we just introduced and, as these will be
5877 # expanded by make, quote '$'.
5878 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5879
5880 # Add in --program-transform-name, after --program-prefix and
5881 # --program-suffix have been applied to it.  Autoconf has already
5882 # doubled dollar signs and backslashes in program_transform_name; we want
5883 # the backslashes un-doubled, and then the entire thing wrapped in single
5884 # quotes, because this will be expanded first by make and then by the shell.
5885 # Also, because we want to override the logic in subdir configure scripts to
5886 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5887 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5888 ${program_transform_name}
5889 EOF_SED
5890 gcc_transform_name=`cat conftestsed.out`
5891 rm -f conftestsed.out
5892 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5893 if test "$silent" = yes; then
5894   baseargs="$baseargs --silent"
5895 fi
5896
5897 # For the build-side libraries, we just need to pretend we're native,
5898 # and not use the same cache file.  Multilibs are neither needed nor
5899 # desired.
5900 build_configargs="--cache-file=../config.cache ${baseargs}"
5901
5902 # For host modules, accept cache file option, or specification as blank.
5903 case "${cache_file}" in
5904 "") # empty
5905   cache_file_option="" ;;
5906 /* | [A-Za-z]:[\\/]* ) # absolute path
5907   cache_file_option="--cache-file=${cache_file}" ;;
5908 *) # relative path
5909   cache_file_option="--cache-file=../${cache_file}" ;;
5910 esac
5911
5912 # Host dirs don't like to share a cache file either, horribly enough.
5913 # This seems to be due to autoconf 2.5x stupidity.
5914 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5915
5916 target_configargs=${baseargs}
5917
5918 # Passing a --with-cross-host argument lets the target libraries know
5919 # whether they are being built with a cross-compiler or being built
5920 # native.  However, it would be better to use other mechanisms to make the
5921 # sorts of decisions they want to make on this basis.  Please consider
5922 # this option to be deprecated.  FIXME.
5923 if test x${is_cross_compiler} = xyes ; then
5924   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5925 fi
5926
5927 # Default to --enable-multilib.
5928 if test x${enable_multilib} = x ; then
5929   target_configargs="--enable-multilib ${target_configargs}"
5930 fi
5931
5932 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5933 # changed from the earlier setting of with_newlib.
5934 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5935   target_configargs="--with-newlib ${target_configargs}"
5936 fi
5937
5938 # Different target subdirs use different values of certain variables
5939 # (notably CXX).  Worse, multilibs use *lots* of different values.
5940 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5941 # it doesn't automatically accept command-line overrides of them.
5942 # This means it's not safe for target subdirs to share a cache file,
5943 # which is disgusting, but there you have it.  Hopefully this can be
5944 # fixed in future.  It's still worthwhile to use a cache file for each
5945 # directory.  I think.
5946
5947 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5948 # We need to pass --target, as newer autoconf's requires consistency
5949 # for target_alias and gcc doesn't manage it consistently.
5950 target_configargs="--cache-file=./config.cache ${target_configargs}"
5951
5952 FLAGS_FOR_TARGET=
5953 case " $target_configdirs " in
5954  *" newlib "*)
5955   case " $target_configargs " in
5956   *" --with-newlib "*)
5957    case "$target" in
5958    *-cygwin*)
5959      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' ;;
5960    esac
5961
5962    # If we're not building GCC, don't discard standard headers.
5963    if test -d ${srcdir}/gcc; then
5964      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5965
5966      if test "${build}" != "${host}"; then
5967        # On Canadian crosses, CC_FOR_TARGET will have already been set
5968        # by `configure', so we won't have an opportunity to add -Bgcc/
5969        # to it.  This is right: we don't want to search that directory
5970        # for binaries, but we want the header files in there, so add
5971        # them explicitly.
5972        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5973
5974        # Someone might think of using the pre-installed headers on
5975        # Canadian crosses, in case the installed compiler is not fully
5976        # compatible with the compiler being built.  In this case, it
5977        # would be better to flag an error than risking having
5978        # incompatible object files being constructed.  We can't
5979        # guarantee that an error will be flagged, but let's hope the
5980        # compiler will do it, when presented with incompatible header
5981        # files.
5982      fi
5983    fi
5984
5985    case "${target}-${is_cross_compiler}" in
5986    i[3456789]86-*-linux*-no)
5987       # Here host == target, so we don't need to build gcc,
5988       # so we don't want to discard standard headers.
5989       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5990       ;;
5991    *)
5992       # If we're building newlib, use its generic headers last, but search
5993       # for any libc-related directories first (so make it the last -B
5994       # switch).
5995       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5996
5997       # If we're building libgloss, find the startup file, simulator library
5998       # and linker script.
5999       case " $target_configdirs " in
6000         *" libgloss "*)
6001         # Look for startup file, simulator library and maybe linker script.
6002         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6003         # Look for libnosys.a in case the target needs it.
6004         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6005         # Most targets have the linker script in the source directory.
6006         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6007         ;;
6008       esac
6009       ;;
6010    esac
6011    ;;
6012   esac
6013   ;;
6014 esac
6015 case "$target" in
6016 *-mingw*)
6017   # Can't be handled as Cygwin above since Mingw does not use newlib.
6018   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/winsup/mingw -L$$r/$(TARGET_SUBDIR)/winsup/w32api/lib -isystem $$s/winsup/mingw/include -isystem $$s/winsup/w32api/include' ;;
6019 esac
6020
6021 # Allow the user to override the flags for
6022 # our build compiler if desired.
6023 if test x"${build}" = x"${host}" ; then
6024   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6025   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6026   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6027 fi
6028
6029 # On Canadian crosses, we'll be searching the right directories for
6030 # the previously-installed cross compiler, so don't bother to add
6031 # flags for directories within the install tree of the compiler
6032 # being built; programs in there won't even run.
6033 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6034   # Search for pre-installed headers if nothing else fits.
6035   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6036 fi
6037
6038 if test "x${use_gnu_ld}" = x &&
6039    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6040   # Arrange for us to find uninstalled linker scripts.
6041   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6042 fi
6043
6044 # Search for other target-specific linker scripts and such.
6045 case "${target}" in
6046   mep*)
6047     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6048     ;;
6049 esac
6050
6051 # Makefile fragments.
6052 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6053 do
6054   eval fragval=\$$frag
6055   if test $fragval != /dev/null; then
6056     eval $frag=${srcdir}/$fragval
6057   fi
6058 done
6059
6060
6061
6062
6063
6064 # Miscellanea: directories, flags, etc.
6065
6066
6067
6068
6069
6070
6071
6072 # Build module lists & subconfigure args.
6073
6074
6075
6076 # Host module lists & subconfigure args.
6077
6078
6079
6080 # Target module lists & subconfigure args.
6081
6082
6083
6084 # Build tools.
6085
6086
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102 # Generate default definitions for YACC, M4, LEX and other programs that run
6103 # on the build machine.  These are used if the Makefile can't locate these
6104 # programs in objdir.
6105 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6106
6107 for ac_prog in 'bison -y' byacc yacc
6108 do
6109   # Extract the first word of "$ac_prog", so it can be a program name with args.
6110 set dummy $ac_prog; ac_word=$2
6111 echo "$as_me:$LINENO: checking for $ac_word" >&5
6112 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6113 if test "${ac_cv_prog_YACC+set}" = set; then
6114   echo $ECHO_N "(cached) $ECHO_C" >&6
6115 else
6116   if test -n "$YACC"; then
6117   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6118 else
6119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6120 for as_dir in $PATH
6121 do
6122   IFS=$as_save_IFS
6123   test -z "$as_dir" && as_dir=.
6124   for ac_exec_ext in '' $ac_executable_extensions; do
6125   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6126     ac_cv_prog_YACC="$ac_prog"
6127     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6128     break 2
6129   fi
6130 done
6131 done
6132
6133 fi
6134 fi
6135 YACC=$ac_cv_prog_YACC
6136 if test -n "$YACC"; then
6137   echo "$as_me:$LINENO: result: $YACC" >&5
6138 echo "${ECHO_T}$YACC" >&6
6139 else
6140   echo "$as_me:$LINENO: result: no" >&5
6141 echo "${ECHO_T}no" >&6
6142 fi
6143
6144   test -n "$YACC" && break
6145 done
6146 test -n "$YACC" || YACC="$MISSING bison -y"
6147
6148 case " $build_configdirs " in
6149   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6150   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6151 esac
6152
6153 for ac_prog in bison
6154 do
6155   # Extract the first word of "$ac_prog", so it can be a program name with args.
6156 set dummy $ac_prog; ac_word=$2
6157 echo "$as_me:$LINENO: checking for $ac_word" >&5
6158 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6159 if test "${ac_cv_prog_BISON+set}" = set; then
6160   echo $ECHO_N "(cached) $ECHO_C" >&6
6161 else
6162   if test -n "$BISON"; then
6163   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6164 else
6165 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6166 for as_dir in $PATH
6167 do
6168   IFS=$as_save_IFS
6169   test -z "$as_dir" && as_dir=.
6170   for ac_exec_ext in '' $ac_executable_extensions; do
6171   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6172     ac_cv_prog_BISON="$ac_prog"
6173     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6174     break 2
6175   fi
6176 done
6177 done
6178
6179 fi
6180 fi
6181 BISON=$ac_cv_prog_BISON
6182 if test -n "$BISON"; then
6183   echo "$as_me:$LINENO: result: $BISON" >&5
6184 echo "${ECHO_T}$BISON" >&6
6185 else
6186   echo "$as_me:$LINENO: result: no" >&5
6187 echo "${ECHO_T}no" >&6
6188 fi
6189
6190   test -n "$BISON" && break
6191 done
6192 test -n "$BISON" || BISON="$MISSING bison"
6193
6194 case " $build_configdirs " in
6195   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6196 esac
6197
6198 for ac_prog in gm4 gnum4 m4
6199 do
6200   # Extract the first word of "$ac_prog", so it can be a program name with args.
6201 set dummy $ac_prog; ac_word=$2
6202 echo "$as_me:$LINENO: checking for $ac_word" >&5
6203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6204 if test "${ac_cv_prog_M4+set}" = set; then
6205   echo $ECHO_N "(cached) $ECHO_C" >&6
6206 else
6207   if test -n "$M4"; then
6208   ac_cv_prog_M4="$M4" # Let the user override the test.
6209 else
6210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6211 for as_dir in $PATH
6212 do
6213   IFS=$as_save_IFS
6214   test -z "$as_dir" && as_dir=.
6215   for ac_exec_ext in '' $ac_executable_extensions; do
6216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6217     ac_cv_prog_M4="$ac_prog"
6218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6219     break 2
6220   fi
6221 done
6222 done
6223
6224 fi
6225 fi
6226 M4=$ac_cv_prog_M4
6227 if test -n "$M4"; then
6228   echo "$as_me:$LINENO: result: $M4" >&5
6229 echo "${ECHO_T}$M4" >&6
6230 else
6231   echo "$as_me:$LINENO: result: no" >&5
6232 echo "${ECHO_T}no" >&6
6233 fi
6234
6235   test -n "$M4" && break
6236 done
6237 test -n "$M4" || M4="$MISSING m4"
6238
6239 case " $build_configdirs " in
6240   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6241 esac
6242
6243 for ac_prog in flex lex
6244 do
6245   # Extract the first word of "$ac_prog", so it can be a program name with args.
6246 set dummy $ac_prog; ac_word=$2
6247 echo "$as_me:$LINENO: checking for $ac_word" >&5
6248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6249 if test "${ac_cv_prog_LEX+set}" = set; then
6250   echo $ECHO_N "(cached) $ECHO_C" >&6
6251 else
6252   if test -n "$LEX"; then
6253   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6254 else
6255 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6256 for as_dir in $PATH
6257 do
6258   IFS=$as_save_IFS
6259   test -z "$as_dir" && as_dir=.
6260   for ac_exec_ext in '' $ac_executable_extensions; do
6261   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6262     ac_cv_prog_LEX="$ac_prog"
6263     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6264     break 2
6265   fi
6266 done
6267 done
6268
6269 fi
6270 fi
6271 LEX=$ac_cv_prog_LEX
6272 if test -n "$LEX"; then
6273   echo "$as_me:$LINENO: result: $LEX" >&5
6274 echo "${ECHO_T}$LEX" >&6
6275 else
6276   echo "$as_me:$LINENO: result: no" >&5
6277 echo "${ECHO_T}no" >&6
6278 fi
6279
6280   test -n "$LEX" && break
6281 done
6282 test -n "$LEX" || LEX="$MISSING flex"
6283
6284 case " $build_configdirs " in
6285   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6286   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6287 esac
6288
6289 for ac_prog in flex
6290 do
6291   # Extract the first word of "$ac_prog", so it can be a program name with args.
6292 set dummy $ac_prog; ac_word=$2
6293 echo "$as_me:$LINENO: checking for $ac_word" >&5
6294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6295 if test "${ac_cv_prog_FLEX+set}" = set; then
6296   echo $ECHO_N "(cached) $ECHO_C" >&6
6297 else
6298   if test -n "$FLEX"; then
6299   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6300 else
6301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6302 for as_dir in $PATH
6303 do
6304   IFS=$as_save_IFS
6305   test -z "$as_dir" && as_dir=.
6306   for ac_exec_ext in '' $ac_executable_extensions; do
6307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6308     ac_cv_prog_FLEX="$ac_prog"
6309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6310     break 2
6311   fi
6312 done
6313 done
6314
6315 fi
6316 fi
6317 FLEX=$ac_cv_prog_FLEX
6318 if test -n "$FLEX"; then
6319   echo "$as_me:$LINENO: result: $FLEX" >&5
6320 echo "${ECHO_T}$FLEX" >&6
6321 else
6322   echo "$as_me:$LINENO: result: no" >&5
6323 echo "${ECHO_T}no" >&6
6324 fi
6325
6326   test -n "$FLEX" && break
6327 done
6328 test -n "$FLEX" || FLEX="$MISSING flex"
6329
6330 case " $build_configdirs " in
6331   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6332 esac
6333
6334 for ac_prog in makeinfo
6335 do
6336   # Extract the first word of "$ac_prog", so it can be a program name with args.
6337 set dummy $ac_prog; ac_word=$2
6338 echo "$as_me:$LINENO: checking for $ac_word" >&5
6339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6340 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6341   echo $ECHO_N "(cached) $ECHO_C" >&6
6342 else
6343   if test -n "$MAKEINFO"; then
6344   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6345 else
6346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6347 for as_dir in $PATH
6348 do
6349   IFS=$as_save_IFS
6350   test -z "$as_dir" && as_dir=.
6351   for ac_exec_ext in '' $ac_executable_extensions; do
6352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6353     ac_cv_prog_MAKEINFO="$ac_prog"
6354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6355     break 2
6356   fi
6357 done
6358 done
6359
6360 fi
6361 fi
6362 MAKEINFO=$ac_cv_prog_MAKEINFO
6363 if test -n "$MAKEINFO"; then
6364   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6365 echo "${ECHO_T}$MAKEINFO" >&6
6366 else
6367   echo "$as_me:$LINENO: result: no" >&5
6368 echo "${ECHO_T}no" >&6
6369 fi
6370
6371   test -n "$MAKEINFO" && break
6372 done
6373 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6374
6375 case " $build_configdirs " in
6376   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6377   *)
6378
6379     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6380     # higher, else we use the "missing" dummy.
6381     if ${MAKEINFO} --version \
6382        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6383       :
6384     else
6385       MAKEINFO="$MISSING makeinfo"
6386     fi
6387     ;;
6388
6389 esac
6390
6391 # FIXME: expect and dejagnu may become build tools?
6392
6393 for ac_prog in expect
6394 do
6395   # Extract the first word of "$ac_prog", so it can be a program name with args.
6396 set dummy $ac_prog; ac_word=$2
6397 echo "$as_me:$LINENO: checking for $ac_word" >&5
6398 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6399 if test "${ac_cv_prog_EXPECT+set}" = set; then
6400   echo $ECHO_N "(cached) $ECHO_C" >&6
6401 else
6402   if test -n "$EXPECT"; then
6403   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6404 else
6405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6406 for as_dir in $PATH
6407 do
6408   IFS=$as_save_IFS
6409   test -z "$as_dir" && as_dir=.
6410   for ac_exec_ext in '' $ac_executable_extensions; do
6411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6412     ac_cv_prog_EXPECT="$ac_prog"
6413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6414     break 2
6415   fi
6416 done
6417 done
6418
6419 fi
6420 fi
6421 EXPECT=$ac_cv_prog_EXPECT
6422 if test -n "$EXPECT"; then
6423   echo "$as_me:$LINENO: result: $EXPECT" >&5
6424 echo "${ECHO_T}$EXPECT" >&6
6425 else
6426   echo "$as_me:$LINENO: result: no" >&5
6427 echo "${ECHO_T}no" >&6
6428 fi
6429
6430   test -n "$EXPECT" && break
6431 done
6432 test -n "$EXPECT" || EXPECT="expect"
6433
6434 case " $configdirs " in
6435   *" expect "*)
6436     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6437     ;;
6438 esac
6439
6440 for ac_prog in runtest
6441 do
6442   # Extract the first word of "$ac_prog", so it can be a program name with args.
6443 set dummy $ac_prog; ac_word=$2
6444 echo "$as_me:$LINENO: checking for $ac_word" >&5
6445 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6446 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6447   echo $ECHO_N "(cached) $ECHO_C" >&6
6448 else
6449   if test -n "$RUNTEST"; then
6450   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6451 else
6452 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6453 for as_dir in $PATH
6454 do
6455   IFS=$as_save_IFS
6456   test -z "$as_dir" && as_dir=.
6457   for ac_exec_ext in '' $ac_executable_extensions; do
6458   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6459     ac_cv_prog_RUNTEST="$ac_prog"
6460     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6461     break 2
6462   fi
6463 done
6464 done
6465
6466 fi
6467 fi
6468 RUNTEST=$ac_cv_prog_RUNTEST
6469 if test -n "$RUNTEST"; then
6470   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6471 echo "${ECHO_T}$RUNTEST" >&6
6472 else
6473   echo "$as_me:$LINENO: result: no" >&5
6474 echo "${ECHO_T}no" >&6
6475 fi
6476
6477   test -n "$RUNTEST" && break
6478 done
6479 test -n "$RUNTEST" || RUNTEST="runtest"
6480
6481 case " $configdirs " in
6482   *" dejagnu "*)
6483     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6484     ;;
6485 esac
6486
6487
6488 # Host tools.
6489 ncn_tool_prefix=
6490 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6491 ncn_target_tool_prefix=
6492 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6493
6494
6495
6496 if test -n "$AR"; then
6497   ac_cv_prog_AR=$AR
6498 elif test -n "$ac_cv_prog_AR"; then
6499   AR=$ac_cv_prog_AR
6500 fi
6501
6502 if test -n "$ac_cv_prog_AR"; then
6503   for ncn_progname in ar; do
6504     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6505 set dummy ${ncn_progname}; ac_word=$2
6506 echo "$as_me:$LINENO: checking for $ac_word" >&5
6507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6508 if test "${ac_cv_prog_AR+set}" = set; then
6509   echo $ECHO_N "(cached) $ECHO_C" >&6
6510 else
6511   if test -n "$AR"; then
6512   ac_cv_prog_AR="$AR" # Let the user override the test.
6513 else
6514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6515 for as_dir in $PATH
6516 do
6517   IFS=$as_save_IFS
6518   test -z "$as_dir" && as_dir=.
6519   for ac_exec_ext in '' $ac_executable_extensions; do
6520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6521     ac_cv_prog_AR="${ncn_progname}"
6522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6523     break 2
6524   fi
6525 done
6526 done
6527
6528 fi
6529 fi
6530 AR=$ac_cv_prog_AR
6531 if test -n "$AR"; then
6532   echo "$as_me:$LINENO: result: $AR" >&5
6533 echo "${ECHO_T}$AR" >&6
6534 else
6535   echo "$as_me:$LINENO: result: no" >&5
6536 echo "${ECHO_T}no" >&6
6537 fi
6538
6539   done
6540 fi
6541
6542 for ncn_progname in ar; do
6543   if test -n "$ncn_tool_prefix"; then
6544     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6545 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6546 echo "$as_me:$LINENO: checking for $ac_word" >&5
6547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6548 if test "${ac_cv_prog_AR+set}" = set; then
6549   echo $ECHO_N "(cached) $ECHO_C" >&6
6550 else
6551   if test -n "$AR"; then
6552   ac_cv_prog_AR="$AR" # Let the user override the test.
6553 else
6554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6555 for as_dir in $PATH
6556 do
6557   IFS=$as_save_IFS
6558   test -z "$as_dir" && as_dir=.
6559   for ac_exec_ext in '' $ac_executable_extensions; do
6560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6561     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6563     break 2
6564   fi
6565 done
6566 done
6567
6568 fi
6569 fi
6570 AR=$ac_cv_prog_AR
6571 if test -n "$AR"; then
6572   echo "$as_me:$LINENO: result: $AR" >&5
6573 echo "${ECHO_T}$AR" >&6
6574 else
6575   echo "$as_me:$LINENO: result: no" >&5
6576 echo "${ECHO_T}no" >&6
6577 fi
6578
6579   fi
6580   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6581     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6582 set dummy ${ncn_progname}; ac_word=$2
6583 echo "$as_me:$LINENO: checking for $ac_word" >&5
6584 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6585 if test "${ac_cv_prog_AR+set}" = set; then
6586   echo $ECHO_N "(cached) $ECHO_C" >&6
6587 else
6588   if test -n "$AR"; then
6589   ac_cv_prog_AR="$AR" # Let the user override the test.
6590 else
6591 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6592 for as_dir in $PATH
6593 do
6594   IFS=$as_save_IFS
6595   test -z "$as_dir" && as_dir=.
6596   for ac_exec_ext in '' $ac_executable_extensions; do
6597   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6598     ac_cv_prog_AR="${ncn_progname}"
6599     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6600     break 2
6601   fi
6602 done
6603 done
6604
6605 fi
6606 fi
6607 AR=$ac_cv_prog_AR
6608 if test -n "$AR"; then
6609   echo "$as_me:$LINENO: result: $AR" >&5
6610 echo "${ECHO_T}$AR" >&6
6611 else
6612   echo "$as_me:$LINENO: result: no" >&5
6613 echo "${ECHO_T}no" >&6
6614 fi
6615
6616   fi
6617   test -n "$ac_cv_prog_AR" && break
6618 done
6619
6620 if test -z "$ac_cv_prog_AR" ; then
6621   set dummy ar
6622   if test $build = $host ; then
6623     AR="$2"
6624   else
6625     AR="${ncn_tool_prefix}$2"
6626   fi
6627 fi
6628
6629
6630
6631 if test -n "$AS"; then
6632   ac_cv_prog_AS=$AS
6633 elif test -n "$ac_cv_prog_AS"; then
6634   AS=$ac_cv_prog_AS
6635 fi
6636
6637 if test -n "$ac_cv_prog_AS"; then
6638   for ncn_progname in as; do
6639     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6640 set dummy ${ncn_progname}; ac_word=$2
6641 echo "$as_me:$LINENO: checking for $ac_word" >&5
6642 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6643 if test "${ac_cv_prog_AS+set}" = set; then
6644   echo $ECHO_N "(cached) $ECHO_C" >&6
6645 else
6646   if test -n "$AS"; then
6647   ac_cv_prog_AS="$AS" # Let the user override the test.
6648 else
6649 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6650 for as_dir in $PATH
6651 do
6652   IFS=$as_save_IFS
6653   test -z "$as_dir" && as_dir=.
6654   for ac_exec_ext in '' $ac_executable_extensions; do
6655   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6656     ac_cv_prog_AS="${ncn_progname}"
6657     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6658     break 2
6659   fi
6660 done
6661 done
6662
6663 fi
6664 fi
6665 AS=$ac_cv_prog_AS
6666 if test -n "$AS"; then
6667   echo "$as_me:$LINENO: result: $AS" >&5
6668 echo "${ECHO_T}$AS" >&6
6669 else
6670   echo "$as_me:$LINENO: result: no" >&5
6671 echo "${ECHO_T}no" >&6
6672 fi
6673
6674   done
6675 fi
6676
6677 for ncn_progname in as; do
6678   if test -n "$ncn_tool_prefix"; then
6679     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6680 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6681 echo "$as_me:$LINENO: checking for $ac_word" >&5
6682 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6683 if test "${ac_cv_prog_AS+set}" = set; then
6684   echo $ECHO_N "(cached) $ECHO_C" >&6
6685 else
6686   if test -n "$AS"; then
6687   ac_cv_prog_AS="$AS" # Let the user override the test.
6688 else
6689 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6690 for as_dir in $PATH
6691 do
6692   IFS=$as_save_IFS
6693   test -z "$as_dir" && as_dir=.
6694   for ac_exec_ext in '' $ac_executable_extensions; do
6695   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6696     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6697     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6698     break 2
6699   fi
6700 done
6701 done
6702
6703 fi
6704 fi
6705 AS=$ac_cv_prog_AS
6706 if test -n "$AS"; then
6707   echo "$as_me:$LINENO: result: $AS" >&5
6708 echo "${ECHO_T}$AS" >&6
6709 else
6710   echo "$as_me:$LINENO: result: no" >&5
6711 echo "${ECHO_T}no" >&6
6712 fi
6713
6714   fi
6715   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6716     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6717 set dummy ${ncn_progname}; ac_word=$2
6718 echo "$as_me:$LINENO: checking for $ac_word" >&5
6719 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6720 if test "${ac_cv_prog_AS+set}" = set; then
6721   echo $ECHO_N "(cached) $ECHO_C" >&6
6722 else
6723   if test -n "$AS"; then
6724   ac_cv_prog_AS="$AS" # Let the user override the test.
6725 else
6726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6727 for as_dir in $PATH
6728 do
6729   IFS=$as_save_IFS
6730   test -z "$as_dir" && as_dir=.
6731   for ac_exec_ext in '' $ac_executable_extensions; do
6732   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6733     ac_cv_prog_AS="${ncn_progname}"
6734     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6735     break 2
6736   fi
6737 done
6738 done
6739
6740 fi
6741 fi
6742 AS=$ac_cv_prog_AS
6743 if test -n "$AS"; then
6744   echo "$as_me:$LINENO: result: $AS" >&5
6745 echo "${ECHO_T}$AS" >&6
6746 else
6747   echo "$as_me:$LINENO: result: no" >&5
6748 echo "${ECHO_T}no" >&6
6749 fi
6750
6751   fi
6752   test -n "$ac_cv_prog_AS" && break
6753 done
6754
6755 if test -z "$ac_cv_prog_AS" ; then
6756   set dummy as
6757   if test $build = $host ; then
6758     AS="$2"
6759   else
6760     AS="${ncn_tool_prefix}$2"
6761   fi
6762 fi
6763
6764
6765
6766 if test -n "$DLLTOOL"; then
6767   ac_cv_prog_DLLTOOL=$DLLTOOL
6768 elif test -n "$ac_cv_prog_DLLTOOL"; then
6769   DLLTOOL=$ac_cv_prog_DLLTOOL
6770 fi
6771
6772 if test -n "$ac_cv_prog_DLLTOOL"; then
6773   for ncn_progname in dlltool; do
6774     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6775 set dummy ${ncn_progname}; ac_word=$2
6776 echo "$as_me:$LINENO: checking for $ac_word" >&5
6777 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6778 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6779   echo $ECHO_N "(cached) $ECHO_C" >&6
6780 else
6781   if test -n "$DLLTOOL"; then
6782   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6783 else
6784 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6785 for as_dir in $PATH
6786 do
6787   IFS=$as_save_IFS
6788   test -z "$as_dir" && as_dir=.
6789   for ac_exec_ext in '' $ac_executable_extensions; do
6790   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6791     ac_cv_prog_DLLTOOL="${ncn_progname}"
6792     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6793     break 2
6794   fi
6795 done
6796 done
6797
6798 fi
6799 fi
6800 DLLTOOL=$ac_cv_prog_DLLTOOL
6801 if test -n "$DLLTOOL"; then
6802   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6803 echo "${ECHO_T}$DLLTOOL" >&6
6804 else
6805   echo "$as_me:$LINENO: result: no" >&5
6806 echo "${ECHO_T}no" >&6
6807 fi
6808
6809   done
6810 fi
6811
6812 for ncn_progname in dlltool; do
6813   if test -n "$ncn_tool_prefix"; then
6814     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6815 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6816 echo "$as_me:$LINENO: checking for $ac_word" >&5
6817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6818 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6819   echo $ECHO_N "(cached) $ECHO_C" >&6
6820 else
6821   if test -n "$DLLTOOL"; then
6822   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6823 else
6824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6825 for as_dir in $PATH
6826 do
6827   IFS=$as_save_IFS
6828   test -z "$as_dir" && as_dir=.
6829   for ac_exec_ext in '' $ac_executable_extensions; do
6830   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6831     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6832     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6833     break 2
6834   fi
6835 done
6836 done
6837
6838 fi
6839 fi
6840 DLLTOOL=$ac_cv_prog_DLLTOOL
6841 if test -n "$DLLTOOL"; then
6842   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6843 echo "${ECHO_T}$DLLTOOL" >&6
6844 else
6845   echo "$as_me:$LINENO: result: no" >&5
6846 echo "${ECHO_T}no" >&6
6847 fi
6848
6849   fi
6850   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6851     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6852 set dummy ${ncn_progname}; ac_word=$2
6853 echo "$as_me:$LINENO: checking for $ac_word" >&5
6854 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6855 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6856   echo $ECHO_N "(cached) $ECHO_C" >&6
6857 else
6858   if test -n "$DLLTOOL"; then
6859   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6860 else
6861 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6862 for as_dir in $PATH
6863 do
6864   IFS=$as_save_IFS
6865   test -z "$as_dir" && as_dir=.
6866   for ac_exec_ext in '' $ac_executable_extensions; do
6867   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6868     ac_cv_prog_DLLTOOL="${ncn_progname}"
6869     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6870     break 2
6871   fi
6872 done
6873 done
6874
6875 fi
6876 fi
6877 DLLTOOL=$ac_cv_prog_DLLTOOL
6878 if test -n "$DLLTOOL"; then
6879   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6880 echo "${ECHO_T}$DLLTOOL" >&6
6881 else
6882   echo "$as_me:$LINENO: result: no" >&5
6883 echo "${ECHO_T}no" >&6
6884 fi
6885
6886   fi
6887   test -n "$ac_cv_prog_DLLTOOL" && break
6888 done
6889
6890 if test -z "$ac_cv_prog_DLLTOOL" ; then
6891   set dummy dlltool
6892   if test $build = $host ; then
6893     DLLTOOL="$2"
6894   else
6895     DLLTOOL="${ncn_tool_prefix}$2"
6896   fi
6897 fi
6898
6899
6900
6901 if test -n "$LD"; then
6902   ac_cv_prog_LD=$LD
6903 elif test -n "$ac_cv_prog_LD"; then
6904   LD=$ac_cv_prog_LD
6905 fi
6906
6907 if test -n "$ac_cv_prog_LD"; then
6908   for ncn_progname in ld; do
6909     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6910 set dummy ${ncn_progname}; ac_word=$2
6911 echo "$as_me:$LINENO: checking for $ac_word" >&5
6912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6913 if test "${ac_cv_prog_LD+set}" = set; then
6914   echo $ECHO_N "(cached) $ECHO_C" >&6
6915 else
6916   if test -n "$LD"; then
6917   ac_cv_prog_LD="$LD" # Let the user override the test.
6918 else
6919 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6920 for as_dir in $PATH
6921 do
6922   IFS=$as_save_IFS
6923   test -z "$as_dir" && as_dir=.
6924   for ac_exec_ext in '' $ac_executable_extensions; do
6925   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6926     ac_cv_prog_LD="${ncn_progname}"
6927     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6928     break 2
6929   fi
6930 done
6931 done
6932
6933 fi
6934 fi
6935 LD=$ac_cv_prog_LD
6936 if test -n "$LD"; then
6937   echo "$as_me:$LINENO: result: $LD" >&5
6938 echo "${ECHO_T}$LD" >&6
6939 else
6940   echo "$as_me:$LINENO: result: no" >&5
6941 echo "${ECHO_T}no" >&6
6942 fi
6943
6944   done
6945 fi
6946
6947 for ncn_progname in ld; do
6948   if test -n "$ncn_tool_prefix"; then
6949     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6950 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6951 echo "$as_me:$LINENO: checking for $ac_word" >&5
6952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6953 if test "${ac_cv_prog_LD+set}" = set; then
6954   echo $ECHO_N "(cached) $ECHO_C" >&6
6955 else
6956   if test -n "$LD"; then
6957   ac_cv_prog_LD="$LD" # Let the user override the test.
6958 else
6959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6960 for as_dir in $PATH
6961 do
6962   IFS=$as_save_IFS
6963   test -z "$as_dir" && as_dir=.
6964   for ac_exec_ext in '' $ac_executable_extensions; do
6965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6966     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6968     break 2
6969   fi
6970 done
6971 done
6972
6973 fi
6974 fi
6975 LD=$ac_cv_prog_LD
6976 if test -n "$LD"; then
6977   echo "$as_me:$LINENO: result: $LD" >&5
6978 echo "${ECHO_T}$LD" >&6
6979 else
6980   echo "$as_me:$LINENO: result: no" >&5
6981 echo "${ECHO_T}no" >&6
6982 fi
6983
6984   fi
6985   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6986     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6987 set dummy ${ncn_progname}; ac_word=$2
6988 echo "$as_me:$LINENO: checking for $ac_word" >&5
6989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6990 if test "${ac_cv_prog_LD+set}" = set; then
6991   echo $ECHO_N "(cached) $ECHO_C" >&6
6992 else
6993   if test -n "$LD"; then
6994   ac_cv_prog_LD="$LD" # Let the user override the test.
6995 else
6996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6997 for as_dir in $PATH
6998 do
6999   IFS=$as_save_IFS
7000   test -z "$as_dir" && as_dir=.
7001   for ac_exec_ext in '' $ac_executable_extensions; do
7002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7003     ac_cv_prog_LD="${ncn_progname}"
7004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7005     break 2
7006   fi
7007 done
7008 done
7009
7010 fi
7011 fi
7012 LD=$ac_cv_prog_LD
7013 if test -n "$LD"; then
7014   echo "$as_me:$LINENO: result: $LD" >&5
7015 echo "${ECHO_T}$LD" >&6
7016 else
7017   echo "$as_me:$LINENO: result: no" >&5
7018 echo "${ECHO_T}no" >&6
7019 fi
7020
7021   fi
7022   test -n "$ac_cv_prog_LD" && break
7023 done
7024
7025 if test -z "$ac_cv_prog_LD" ; then
7026   set dummy ld
7027   if test $build = $host ; then
7028     LD="$2"
7029   else
7030     LD="${ncn_tool_prefix}$2"
7031   fi
7032 fi
7033
7034
7035
7036 if test -n "$LIPO"; then
7037   ac_cv_prog_LIPO=$LIPO
7038 elif test -n "$ac_cv_prog_LIPO"; then
7039   LIPO=$ac_cv_prog_LIPO
7040 fi
7041
7042 if test -n "$ac_cv_prog_LIPO"; then
7043   for ncn_progname in lipo; do
7044     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7045 set dummy ${ncn_progname}; ac_word=$2
7046 echo "$as_me:$LINENO: checking for $ac_word" >&5
7047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7048 if test "${ac_cv_prog_LIPO+set}" = set; then
7049   echo $ECHO_N "(cached) $ECHO_C" >&6
7050 else
7051   if test -n "$LIPO"; then
7052   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7053 else
7054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7055 for as_dir in $PATH
7056 do
7057   IFS=$as_save_IFS
7058   test -z "$as_dir" && as_dir=.
7059   for ac_exec_ext in '' $ac_executable_extensions; do
7060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7061     ac_cv_prog_LIPO="${ncn_progname}"
7062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7063     break 2
7064   fi
7065 done
7066 done
7067
7068 fi
7069 fi
7070 LIPO=$ac_cv_prog_LIPO
7071 if test -n "$LIPO"; then
7072   echo "$as_me:$LINENO: result: $LIPO" >&5
7073 echo "${ECHO_T}$LIPO" >&6
7074 else
7075   echo "$as_me:$LINENO: result: no" >&5
7076 echo "${ECHO_T}no" >&6
7077 fi
7078
7079   done
7080 fi
7081
7082 for ncn_progname in lipo; do
7083   if test -n "$ncn_tool_prefix"; then
7084     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7085 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7086 echo "$as_me:$LINENO: checking for $ac_word" >&5
7087 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7088 if test "${ac_cv_prog_LIPO+set}" = set; then
7089   echo $ECHO_N "(cached) $ECHO_C" >&6
7090 else
7091   if test -n "$LIPO"; then
7092   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7093 else
7094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7095 for as_dir in $PATH
7096 do
7097   IFS=$as_save_IFS
7098   test -z "$as_dir" && as_dir=.
7099   for ac_exec_ext in '' $ac_executable_extensions; do
7100   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7101     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7102     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7103     break 2
7104   fi
7105 done
7106 done
7107
7108 fi
7109 fi
7110 LIPO=$ac_cv_prog_LIPO
7111 if test -n "$LIPO"; then
7112   echo "$as_me:$LINENO: result: $LIPO" >&5
7113 echo "${ECHO_T}$LIPO" >&6
7114 else
7115   echo "$as_me:$LINENO: result: no" >&5
7116 echo "${ECHO_T}no" >&6
7117 fi
7118
7119   fi
7120   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7121     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7122 set dummy ${ncn_progname}; ac_word=$2
7123 echo "$as_me:$LINENO: checking for $ac_word" >&5
7124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7125 if test "${ac_cv_prog_LIPO+set}" = set; then
7126   echo $ECHO_N "(cached) $ECHO_C" >&6
7127 else
7128   if test -n "$LIPO"; then
7129   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7130 else
7131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7132 for as_dir in $PATH
7133 do
7134   IFS=$as_save_IFS
7135   test -z "$as_dir" && as_dir=.
7136   for ac_exec_ext in '' $ac_executable_extensions; do
7137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7138     ac_cv_prog_LIPO="${ncn_progname}"
7139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7140     break 2
7141   fi
7142 done
7143 done
7144
7145 fi
7146 fi
7147 LIPO=$ac_cv_prog_LIPO
7148 if test -n "$LIPO"; then
7149   echo "$as_me:$LINENO: result: $LIPO" >&5
7150 echo "${ECHO_T}$LIPO" >&6
7151 else
7152   echo "$as_me:$LINENO: result: no" >&5
7153 echo "${ECHO_T}no" >&6
7154 fi
7155
7156   fi
7157   test -n "$ac_cv_prog_LIPO" && break
7158 done
7159
7160 if test -z "$ac_cv_prog_LIPO" ; then
7161   set dummy lipo
7162   if test $build = $host ; then
7163     LIPO="$2"
7164   else
7165     LIPO="${ncn_tool_prefix}$2"
7166   fi
7167 fi
7168
7169
7170
7171 if test -n "$NM"; then
7172   ac_cv_prog_NM=$NM
7173 elif test -n "$ac_cv_prog_NM"; then
7174   NM=$ac_cv_prog_NM
7175 fi
7176
7177 if test -n "$ac_cv_prog_NM"; then
7178   for ncn_progname in nm; do
7179     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7180 set dummy ${ncn_progname}; ac_word=$2
7181 echo "$as_me:$LINENO: checking for $ac_word" >&5
7182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7183 if test "${ac_cv_prog_NM+set}" = set; then
7184   echo $ECHO_N "(cached) $ECHO_C" >&6
7185 else
7186   if test -n "$NM"; then
7187   ac_cv_prog_NM="$NM" # Let the user override the test.
7188 else
7189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7190 for as_dir in $PATH
7191 do
7192   IFS=$as_save_IFS
7193   test -z "$as_dir" && as_dir=.
7194   for ac_exec_ext in '' $ac_executable_extensions; do
7195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7196     ac_cv_prog_NM="${ncn_progname}"
7197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7198     break 2
7199   fi
7200 done
7201 done
7202
7203 fi
7204 fi
7205 NM=$ac_cv_prog_NM
7206 if test -n "$NM"; then
7207   echo "$as_me:$LINENO: result: $NM" >&5
7208 echo "${ECHO_T}$NM" >&6
7209 else
7210   echo "$as_me:$LINENO: result: no" >&5
7211 echo "${ECHO_T}no" >&6
7212 fi
7213
7214   done
7215 fi
7216
7217 for ncn_progname in nm; do
7218   if test -n "$ncn_tool_prefix"; then
7219     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7220 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7221 echo "$as_me:$LINENO: checking for $ac_word" >&5
7222 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7223 if test "${ac_cv_prog_NM+set}" = set; then
7224   echo $ECHO_N "(cached) $ECHO_C" >&6
7225 else
7226   if test -n "$NM"; then
7227   ac_cv_prog_NM="$NM" # Let the user override the test.
7228 else
7229 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7230 for as_dir in $PATH
7231 do
7232   IFS=$as_save_IFS
7233   test -z "$as_dir" && as_dir=.
7234   for ac_exec_ext in '' $ac_executable_extensions; do
7235   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7236     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7237     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7238     break 2
7239   fi
7240 done
7241 done
7242
7243 fi
7244 fi
7245 NM=$ac_cv_prog_NM
7246 if test -n "$NM"; then
7247   echo "$as_me:$LINENO: result: $NM" >&5
7248 echo "${ECHO_T}$NM" >&6
7249 else
7250   echo "$as_me:$LINENO: result: no" >&5
7251 echo "${ECHO_T}no" >&6
7252 fi
7253
7254   fi
7255   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7256     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7257 set dummy ${ncn_progname}; ac_word=$2
7258 echo "$as_me:$LINENO: checking for $ac_word" >&5
7259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7260 if test "${ac_cv_prog_NM+set}" = set; then
7261   echo $ECHO_N "(cached) $ECHO_C" >&6
7262 else
7263   if test -n "$NM"; then
7264   ac_cv_prog_NM="$NM" # Let the user override the test.
7265 else
7266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7267 for as_dir in $PATH
7268 do
7269   IFS=$as_save_IFS
7270   test -z "$as_dir" && as_dir=.
7271   for ac_exec_ext in '' $ac_executable_extensions; do
7272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7273     ac_cv_prog_NM="${ncn_progname}"
7274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7275     break 2
7276   fi
7277 done
7278 done
7279
7280 fi
7281 fi
7282 NM=$ac_cv_prog_NM
7283 if test -n "$NM"; then
7284   echo "$as_me:$LINENO: result: $NM" >&5
7285 echo "${ECHO_T}$NM" >&6
7286 else
7287   echo "$as_me:$LINENO: result: no" >&5
7288 echo "${ECHO_T}no" >&6
7289 fi
7290
7291   fi
7292   test -n "$ac_cv_prog_NM" && break
7293 done
7294
7295 if test -z "$ac_cv_prog_NM" ; then
7296   set dummy nm
7297   if test $build = $host ; then
7298     NM="$2"
7299   else
7300     NM="${ncn_tool_prefix}$2"
7301   fi
7302 fi
7303
7304
7305
7306 if test -n "$RANLIB"; then
7307   ac_cv_prog_RANLIB=$RANLIB
7308 elif test -n "$ac_cv_prog_RANLIB"; then
7309   RANLIB=$ac_cv_prog_RANLIB
7310 fi
7311
7312 if test -n "$ac_cv_prog_RANLIB"; then
7313   for ncn_progname in ranlib; do
7314     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7315 set dummy ${ncn_progname}; ac_word=$2
7316 echo "$as_me:$LINENO: checking for $ac_word" >&5
7317 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7318 if test "${ac_cv_prog_RANLIB+set}" = set; then
7319   echo $ECHO_N "(cached) $ECHO_C" >&6
7320 else
7321   if test -n "$RANLIB"; then
7322   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7323 else
7324 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7325 for as_dir in $PATH
7326 do
7327   IFS=$as_save_IFS
7328   test -z "$as_dir" && as_dir=.
7329   for ac_exec_ext in '' $ac_executable_extensions; do
7330   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7331     ac_cv_prog_RANLIB="${ncn_progname}"
7332     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7333     break 2
7334   fi
7335 done
7336 done
7337
7338 fi
7339 fi
7340 RANLIB=$ac_cv_prog_RANLIB
7341 if test -n "$RANLIB"; then
7342   echo "$as_me:$LINENO: result: $RANLIB" >&5
7343 echo "${ECHO_T}$RANLIB" >&6
7344 else
7345   echo "$as_me:$LINENO: result: no" >&5
7346 echo "${ECHO_T}no" >&6
7347 fi
7348
7349   done
7350 fi
7351
7352 for ncn_progname in ranlib; do
7353   if test -n "$ncn_tool_prefix"; then
7354     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7355 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7356 echo "$as_me:$LINENO: checking for $ac_word" >&5
7357 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7358 if test "${ac_cv_prog_RANLIB+set}" = set; then
7359   echo $ECHO_N "(cached) $ECHO_C" >&6
7360 else
7361   if test -n "$RANLIB"; then
7362   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7363 else
7364 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7365 for as_dir in $PATH
7366 do
7367   IFS=$as_save_IFS
7368   test -z "$as_dir" && as_dir=.
7369   for ac_exec_ext in '' $ac_executable_extensions; do
7370   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7371     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7372     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7373     break 2
7374   fi
7375 done
7376 done
7377
7378 fi
7379 fi
7380 RANLIB=$ac_cv_prog_RANLIB
7381 if test -n "$RANLIB"; then
7382   echo "$as_me:$LINENO: result: $RANLIB" >&5
7383 echo "${ECHO_T}$RANLIB" >&6
7384 else
7385   echo "$as_me:$LINENO: result: no" >&5
7386 echo "${ECHO_T}no" >&6
7387 fi
7388
7389   fi
7390   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7391     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7392 set dummy ${ncn_progname}; ac_word=$2
7393 echo "$as_me:$LINENO: checking for $ac_word" >&5
7394 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7395 if test "${ac_cv_prog_RANLIB+set}" = set; then
7396   echo $ECHO_N "(cached) $ECHO_C" >&6
7397 else
7398   if test -n "$RANLIB"; then
7399   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7400 else
7401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7402 for as_dir in $PATH
7403 do
7404   IFS=$as_save_IFS
7405   test -z "$as_dir" && as_dir=.
7406   for ac_exec_ext in '' $ac_executable_extensions; do
7407   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7408     ac_cv_prog_RANLIB="${ncn_progname}"
7409     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7410     break 2
7411   fi
7412 done
7413 done
7414
7415 fi
7416 fi
7417 RANLIB=$ac_cv_prog_RANLIB
7418 if test -n "$RANLIB"; then
7419   echo "$as_me:$LINENO: result: $RANLIB" >&5
7420 echo "${ECHO_T}$RANLIB" >&6
7421 else
7422   echo "$as_me:$LINENO: result: no" >&5
7423 echo "${ECHO_T}no" >&6
7424 fi
7425
7426   fi
7427   test -n "$ac_cv_prog_RANLIB" && break
7428 done
7429
7430 if test -z "$ac_cv_prog_RANLIB" ; then
7431   RANLIB=":"
7432 fi
7433
7434
7435
7436 if test -n "$STRIP"; then
7437   ac_cv_prog_STRIP=$STRIP
7438 elif test -n "$ac_cv_prog_STRIP"; then
7439   STRIP=$ac_cv_prog_STRIP
7440 fi
7441
7442 if test -n "$ac_cv_prog_STRIP"; then
7443   for ncn_progname in strip; do
7444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7445 set dummy ${ncn_progname}; ac_word=$2
7446 echo "$as_me:$LINENO: checking for $ac_word" >&5
7447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7448 if test "${ac_cv_prog_STRIP+set}" = set; then
7449   echo $ECHO_N "(cached) $ECHO_C" >&6
7450 else
7451   if test -n "$STRIP"; then
7452   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7453 else
7454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7455 for as_dir in $PATH
7456 do
7457   IFS=$as_save_IFS
7458   test -z "$as_dir" && as_dir=.
7459   for ac_exec_ext in '' $ac_executable_extensions; do
7460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7461     ac_cv_prog_STRIP="${ncn_progname}"
7462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7463     break 2
7464   fi
7465 done
7466 done
7467
7468 fi
7469 fi
7470 STRIP=$ac_cv_prog_STRIP
7471 if test -n "$STRIP"; then
7472   echo "$as_me:$LINENO: result: $STRIP" >&5
7473 echo "${ECHO_T}$STRIP" >&6
7474 else
7475   echo "$as_me:$LINENO: result: no" >&5
7476 echo "${ECHO_T}no" >&6
7477 fi
7478
7479   done
7480 fi
7481
7482 for ncn_progname in strip; do
7483   if test -n "$ncn_tool_prefix"; then
7484     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7485 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7486 echo "$as_me:$LINENO: checking for $ac_word" >&5
7487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7488 if test "${ac_cv_prog_STRIP+set}" = set; then
7489   echo $ECHO_N "(cached) $ECHO_C" >&6
7490 else
7491   if test -n "$STRIP"; then
7492   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7493 else
7494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7495 for as_dir in $PATH
7496 do
7497   IFS=$as_save_IFS
7498   test -z "$as_dir" && as_dir=.
7499   for ac_exec_ext in '' $ac_executable_extensions; do
7500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7501     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7503     break 2
7504   fi
7505 done
7506 done
7507
7508 fi
7509 fi
7510 STRIP=$ac_cv_prog_STRIP
7511 if test -n "$STRIP"; then
7512   echo "$as_me:$LINENO: result: $STRIP" >&5
7513 echo "${ECHO_T}$STRIP" >&6
7514 else
7515   echo "$as_me:$LINENO: result: no" >&5
7516 echo "${ECHO_T}no" >&6
7517 fi
7518
7519   fi
7520   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7521     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7522 set dummy ${ncn_progname}; ac_word=$2
7523 echo "$as_me:$LINENO: checking for $ac_word" >&5
7524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7525 if test "${ac_cv_prog_STRIP+set}" = set; then
7526   echo $ECHO_N "(cached) $ECHO_C" >&6
7527 else
7528   if test -n "$STRIP"; then
7529   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7530 else
7531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7532 for as_dir in $PATH
7533 do
7534   IFS=$as_save_IFS
7535   test -z "$as_dir" && as_dir=.
7536   for ac_exec_ext in '' $ac_executable_extensions; do
7537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7538     ac_cv_prog_STRIP="${ncn_progname}"
7539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7540     break 2
7541   fi
7542 done
7543 done
7544
7545 fi
7546 fi
7547 STRIP=$ac_cv_prog_STRIP
7548 if test -n "$STRIP"; then
7549   echo "$as_me:$LINENO: result: $STRIP" >&5
7550 echo "${ECHO_T}$STRIP" >&6
7551 else
7552   echo "$as_me:$LINENO: result: no" >&5
7553 echo "${ECHO_T}no" >&6
7554 fi
7555
7556   fi
7557   test -n "$ac_cv_prog_STRIP" && break
7558 done
7559
7560 if test -z "$ac_cv_prog_STRIP" ; then
7561   STRIP=":"
7562 fi
7563
7564
7565
7566 if test -n "$WINDRES"; then
7567   ac_cv_prog_WINDRES=$WINDRES
7568 elif test -n "$ac_cv_prog_WINDRES"; then
7569   WINDRES=$ac_cv_prog_WINDRES
7570 fi
7571
7572 if test -n "$ac_cv_prog_WINDRES"; then
7573   for ncn_progname in windres; do
7574     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7575 set dummy ${ncn_progname}; ac_word=$2
7576 echo "$as_me:$LINENO: checking for $ac_word" >&5
7577 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7578 if test "${ac_cv_prog_WINDRES+set}" = set; then
7579   echo $ECHO_N "(cached) $ECHO_C" >&6
7580 else
7581   if test -n "$WINDRES"; then
7582   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7583 else
7584 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7585 for as_dir in $PATH
7586 do
7587   IFS=$as_save_IFS
7588   test -z "$as_dir" && as_dir=.
7589   for ac_exec_ext in '' $ac_executable_extensions; do
7590   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7591     ac_cv_prog_WINDRES="${ncn_progname}"
7592     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7593     break 2
7594   fi
7595 done
7596 done
7597
7598 fi
7599 fi
7600 WINDRES=$ac_cv_prog_WINDRES
7601 if test -n "$WINDRES"; then
7602   echo "$as_me:$LINENO: result: $WINDRES" >&5
7603 echo "${ECHO_T}$WINDRES" >&6
7604 else
7605   echo "$as_me:$LINENO: result: no" >&5
7606 echo "${ECHO_T}no" >&6
7607 fi
7608
7609   done
7610 fi
7611
7612 for ncn_progname in windres; do
7613   if test -n "$ncn_tool_prefix"; then
7614     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7615 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7616 echo "$as_me:$LINENO: checking for $ac_word" >&5
7617 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7618 if test "${ac_cv_prog_WINDRES+set}" = set; then
7619   echo $ECHO_N "(cached) $ECHO_C" >&6
7620 else
7621   if test -n "$WINDRES"; then
7622   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7623 else
7624 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7625 for as_dir in $PATH
7626 do
7627   IFS=$as_save_IFS
7628   test -z "$as_dir" && as_dir=.
7629   for ac_exec_ext in '' $ac_executable_extensions; do
7630   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7631     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7632     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7633     break 2
7634   fi
7635 done
7636 done
7637
7638 fi
7639 fi
7640 WINDRES=$ac_cv_prog_WINDRES
7641 if test -n "$WINDRES"; then
7642   echo "$as_me:$LINENO: result: $WINDRES" >&5
7643 echo "${ECHO_T}$WINDRES" >&6
7644 else
7645   echo "$as_me:$LINENO: result: no" >&5
7646 echo "${ECHO_T}no" >&6
7647 fi
7648
7649   fi
7650   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7651     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7652 set dummy ${ncn_progname}; ac_word=$2
7653 echo "$as_me:$LINENO: checking for $ac_word" >&5
7654 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7655 if test "${ac_cv_prog_WINDRES+set}" = set; then
7656   echo $ECHO_N "(cached) $ECHO_C" >&6
7657 else
7658   if test -n "$WINDRES"; then
7659   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7660 else
7661 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7662 for as_dir in $PATH
7663 do
7664   IFS=$as_save_IFS
7665   test -z "$as_dir" && as_dir=.
7666   for ac_exec_ext in '' $ac_executable_extensions; do
7667   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7668     ac_cv_prog_WINDRES="${ncn_progname}"
7669     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7670     break 2
7671   fi
7672 done
7673 done
7674
7675 fi
7676 fi
7677 WINDRES=$ac_cv_prog_WINDRES
7678 if test -n "$WINDRES"; then
7679   echo "$as_me:$LINENO: result: $WINDRES" >&5
7680 echo "${ECHO_T}$WINDRES" >&6
7681 else
7682   echo "$as_me:$LINENO: result: no" >&5
7683 echo "${ECHO_T}no" >&6
7684 fi
7685
7686   fi
7687   test -n "$ac_cv_prog_WINDRES" && break
7688 done
7689
7690 if test -z "$ac_cv_prog_WINDRES" ; then
7691   set dummy windres
7692   if test $build = $host ; then
7693     WINDRES="$2"
7694   else
7695     WINDRES="${ncn_tool_prefix}$2"
7696   fi
7697 fi
7698
7699
7700
7701 if test -n "$WINDMC"; then
7702   ac_cv_prog_WINDMC=$WINDMC
7703 elif test -n "$ac_cv_prog_WINDMC"; then
7704   WINDMC=$ac_cv_prog_WINDMC
7705 fi
7706
7707 if test -n "$ac_cv_prog_WINDMC"; then
7708   for ncn_progname in windmc; do
7709     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7710 set dummy ${ncn_progname}; ac_word=$2
7711 echo "$as_me:$LINENO: checking for $ac_word" >&5
7712 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7713 if test "${ac_cv_prog_WINDMC+set}" = set; then
7714   echo $ECHO_N "(cached) $ECHO_C" >&6
7715 else
7716   if test -n "$WINDMC"; then
7717   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7718 else
7719 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7720 for as_dir in $PATH
7721 do
7722   IFS=$as_save_IFS
7723   test -z "$as_dir" && as_dir=.
7724   for ac_exec_ext in '' $ac_executable_extensions; do
7725   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7726     ac_cv_prog_WINDMC="${ncn_progname}"
7727     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7728     break 2
7729   fi
7730 done
7731 done
7732
7733 fi
7734 fi
7735 WINDMC=$ac_cv_prog_WINDMC
7736 if test -n "$WINDMC"; then
7737   echo "$as_me:$LINENO: result: $WINDMC" >&5
7738 echo "${ECHO_T}$WINDMC" >&6
7739 else
7740   echo "$as_me:$LINENO: result: no" >&5
7741 echo "${ECHO_T}no" >&6
7742 fi
7743
7744   done
7745 fi
7746
7747 for ncn_progname in windmc; do
7748   if test -n "$ncn_tool_prefix"; then
7749     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7750 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7751 echo "$as_me:$LINENO: checking for $ac_word" >&5
7752 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7753 if test "${ac_cv_prog_WINDMC+set}" = set; then
7754   echo $ECHO_N "(cached) $ECHO_C" >&6
7755 else
7756   if test -n "$WINDMC"; then
7757   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7758 else
7759 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7760 for as_dir in $PATH
7761 do
7762   IFS=$as_save_IFS
7763   test -z "$as_dir" && as_dir=.
7764   for ac_exec_ext in '' $ac_executable_extensions; do
7765   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7766     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7767     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7768     break 2
7769   fi
7770 done
7771 done
7772
7773 fi
7774 fi
7775 WINDMC=$ac_cv_prog_WINDMC
7776 if test -n "$WINDMC"; then
7777   echo "$as_me:$LINENO: result: $WINDMC" >&5
7778 echo "${ECHO_T}$WINDMC" >&6
7779 else
7780   echo "$as_me:$LINENO: result: no" >&5
7781 echo "${ECHO_T}no" >&6
7782 fi
7783
7784   fi
7785   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7786     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7787 set dummy ${ncn_progname}; ac_word=$2
7788 echo "$as_me:$LINENO: checking for $ac_word" >&5
7789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7790 if test "${ac_cv_prog_WINDMC+set}" = set; then
7791   echo $ECHO_N "(cached) $ECHO_C" >&6
7792 else
7793   if test -n "$WINDMC"; then
7794   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7795 else
7796 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7797 for as_dir in $PATH
7798 do
7799   IFS=$as_save_IFS
7800   test -z "$as_dir" && as_dir=.
7801   for ac_exec_ext in '' $ac_executable_extensions; do
7802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7803     ac_cv_prog_WINDMC="${ncn_progname}"
7804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7805     break 2
7806   fi
7807 done
7808 done
7809
7810 fi
7811 fi
7812 WINDMC=$ac_cv_prog_WINDMC
7813 if test -n "$WINDMC"; then
7814   echo "$as_me:$LINENO: result: $WINDMC" >&5
7815 echo "${ECHO_T}$WINDMC" >&6
7816 else
7817   echo "$as_me:$LINENO: result: no" >&5
7818 echo "${ECHO_T}no" >&6
7819 fi
7820
7821   fi
7822   test -n "$ac_cv_prog_WINDMC" && break
7823 done
7824
7825 if test -z "$ac_cv_prog_WINDMC" ; then
7826   set dummy windmc
7827   if test $build = $host ; then
7828     WINDMC="$2"
7829   else
7830     WINDMC="${ncn_tool_prefix}$2"
7831   fi
7832 fi
7833
7834
7835
7836 if test -n "$OBJCOPY"; then
7837   ac_cv_prog_OBJCOPY=$OBJCOPY
7838 elif test -n "$ac_cv_prog_OBJCOPY"; then
7839   OBJCOPY=$ac_cv_prog_OBJCOPY
7840 fi
7841
7842 if test -n "$ac_cv_prog_OBJCOPY"; then
7843   for ncn_progname in objcopy; do
7844     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7845 set dummy ${ncn_progname}; ac_word=$2
7846 echo "$as_me:$LINENO: checking for $ac_word" >&5
7847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7848 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7849   echo $ECHO_N "(cached) $ECHO_C" >&6
7850 else
7851   if test -n "$OBJCOPY"; then
7852   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7853 else
7854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7855 for as_dir in $PATH
7856 do
7857   IFS=$as_save_IFS
7858   test -z "$as_dir" && as_dir=.
7859   for ac_exec_ext in '' $ac_executable_extensions; do
7860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7861     ac_cv_prog_OBJCOPY="${ncn_progname}"
7862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7863     break 2
7864   fi
7865 done
7866 done
7867
7868 fi
7869 fi
7870 OBJCOPY=$ac_cv_prog_OBJCOPY
7871 if test -n "$OBJCOPY"; then
7872   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7873 echo "${ECHO_T}$OBJCOPY" >&6
7874 else
7875   echo "$as_me:$LINENO: result: no" >&5
7876 echo "${ECHO_T}no" >&6
7877 fi
7878
7879   done
7880 fi
7881
7882 for ncn_progname in objcopy; do
7883   if test -n "$ncn_tool_prefix"; then
7884     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7885 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7886 echo "$as_me:$LINENO: checking for $ac_word" >&5
7887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7888 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7889   echo $ECHO_N "(cached) $ECHO_C" >&6
7890 else
7891   if test -n "$OBJCOPY"; then
7892   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7893 else
7894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7895 for as_dir in $PATH
7896 do
7897   IFS=$as_save_IFS
7898   test -z "$as_dir" && as_dir=.
7899   for ac_exec_ext in '' $ac_executable_extensions; do
7900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7901     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7903     break 2
7904   fi
7905 done
7906 done
7907
7908 fi
7909 fi
7910 OBJCOPY=$ac_cv_prog_OBJCOPY
7911 if test -n "$OBJCOPY"; then
7912   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7913 echo "${ECHO_T}$OBJCOPY" >&6
7914 else
7915   echo "$as_me:$LINENO: result: no" >&5
7916 echo "${ECHO_T}no" >&6
7917 fi
7918
7919   fi
7920   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7921     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7922 set dummy ${ncn_progname}; ac_word=$2
7923 echo "$as_me:$LINENO: checking for $ac_word" >&5
7924 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7925 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7926   echo $ECHO_N "(cached) $ECHO_C" >&6
7927 else
7928   if test -n "$OBJCOPY"; then
7929   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7930 else
7931 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7932 for as_dir in $PATH
7933 do
7934   IFS=$as_save_IFS
7935   test -z "$as_dir" && as_dir=.
7936   for ac_exec_ext in '' $ac_executable_extensions; do
7937   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7938     ac_cv_prog_OBJCOPY="${ncn_progname}"
7939     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7940     break 2
7941   fi
7942 done
7943 done
7944
7945 fi
7946 fi
7947 OBJCOPY=$ac_cv_prog_OBJCOPY
7948 if test -n "$OBJCOPY"; then
7949   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7950 echo "${ECHO_T}$OBJCOPY" >&6
7951 else
7952   echo "$as_me:$LINENO: result: no" >&5
7953 echo "${ECHO_T}no" >&6
7954 fi
7955
7956   fi
7957   test -n "$ac_cv_prog_OBJCOPY" && break
7958 done
7959
7960 if test -z "$ac_cv_prog_OBJCOPY" ; then
7961   set dummy objcopy
7962   if test $build = $host ; then
7963     OBJCOPY="$2"
7964   else
7965     OBJCOPY="${ncn_tool_prefix}$2"
7966   fi
7967 fi
7968
7969
7970
7971 if test -n "$OBJDUMP"; then
7972   ac_cv_prog_OBJDUMP=$OBJDUMP
7973 elif test -n "$ac_cv_prog_OBJDUMP"; then
7974   OBJDUMP=$ac_cv_prog_OBJDUMP
7975 fi
7976
7977 if test -n "$ac_cv_prog_OBJDUMP"; then
7978   for ncn_progname in objdump; do
7979     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7980 set dummy ${ncn_progname}; ac_word=$2
7981 echo "$as_me:$LINENO: checking for $ac_word" >&5
7982 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7983 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7984   echo $ECHO_N "(cached) $ECHO_C" >&6
7985 else
7986   if test -n "$OBJDUMP"; then
7987   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7988 else
7989 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7990 for as_dir in $PATH
7991 do
7992   IFS=$as_save_IFS
7993   test -z "$as_dir" && as_dir=.
7994   for ac_exec_ext in '' $ac_executable_extensions; do
7995   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7996     ac_cv_prog_OBJDUMP="${ncn_progname}"
7997     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7998     break 2
7999   fi
8000 done
8001 done
8002
8003 fi
8004 fi
8005 OBJDUMP=$ac_cv_prog_OBJDUMP
8006 if test -n "$OBJDUMP"; then
8007   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8008 echo "${ECHO_T}$OBJDUMP" >&6
8009 else
8010   echo "$as_me:$LINENO: result: no" >&5
8011 echo "${ECHO_T}no" >&6
8012 fi
8013
8014   done
8015 fi
8016
8017 for ncn_progname in objdump; do
8018   if test -n "$ncn_tool_prefix"; then
8019     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8020 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8021 echo "$as_me:$LINENO: checking for $ac_word" >&5
8022 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8023 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8024   echo $ECHO_N "(cached) $ECHO_C" >&6
8025 else
8026   if test -n "$OBJDUMP"; then
8027   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8028 else
8029 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8030 for as_dir in $PATH
8031 do
8032   IFS=$as_save_IFS
8033   test -z "$as_dir" && as_dir=.
8034   for ac_exec_ext in '' $ac_executable_extensions; do
8035   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8036     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8037     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8038     break 2
8039   fi
8040 done
8041 done
8042
8043 fi
8044 fi
8045 OBJDUMP=$ac_cv_prog_OBJDUMP
8046 if test -n "$OBJDUMP"; then
8047   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8048 echo "${ECHO_T}$OBJDUMP" >&6
8049 else
8050   echo "$as_me:$LINENO: result: no" >&5
8051 echo "${ECHO_T}no" >&6
8052 fi
8053
8054   fi
8055   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8056     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8057 set dummy ${ncn_progname}; ac_word=$2
8058 echo "$as_me:$LINENO: checking for $ac_word" >&5
8059 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8060 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8061   echo $ECHO_N "(cached) $ECHO_C" >&6
8062 else
8063   if test -n "$OBJDUMP"; then
8064   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8065 else
8066 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8067 for as_dir in $PATH
8068 do
8069   IFS=$as_save_IFS
8070   test -z "$as_dir" && as_dir=.
8071   for ac_exec_ext in '' $ac_executable_extensions; do
8072   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8073     ac_cv_prog_OBJDUMP="${ncn_progname}"
8074     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8075     break 2
8076   fi
8077 done
8078 done
8079
8080 fi
8081 fi
8082 OBJDUMP=$ac_cv_prog_OBJDUMP
8083 if test -n "$OBJDUMP"; then
8084   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8085 echo "${ECHO_T}$OBJDUMP" >&6
8086 else
8087   echo "$as_me:$LINENO: result: no" >&5
8088 echo "${ECHO_T}no" >&6
8089 fi
8090
8091   fi
8092   test -n "$ac_cv_prog_OBJDUMP" && break
8093 done
8094
8095 if test -z "$ac_cv_prog_OBJDUMP" ; then
8096   set dummy objdump
8097   if test $build = $host ; then
8098     OBJDUMP="$2"
8099   else
8100     OBJDUMP="${ncn_tool_prefix}$2"
8101   fi
8102 fi
8103
8104
8105
8106
8107
8108
8109 # Target tools.
8110
8111 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8112 if test "${with_build_time_tools+set}" = set; then
8113   withval="$with_build_time_tools"
8114   case x"$withval" in
8115      x/*) ;;
8116      *)
8117        with_build_time_tools=
8118        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8119 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8120        ;;
8121    esac
8122 else
8123   with_build_time_tools=
8124 fi;
8125
8126
8127
8128 if test -n "$CC_FOR_TARGET"; then
8129   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8130 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8131   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8132 fi
8133
8134 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8135   for ncn_progname in cc gcc; do
8136     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8137 set dummy ${ncn_progname}; ac_word=$2
8138 echo "$as_me:$LINENO: checking for $ac_word" >&5
8139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8140 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8141   echo $ECHO_N "(cached) $ECHO_C" >&6
8142 else
8143   if test -n "$CC_FOR_TARGET"; then
8144   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8145 else
8146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8147 for as_dir in $PATH
8148 do
8149   IFS=$as_save_IFS
8150   test -z "$as_dir" && as_dir=.
8151   for ac_exec_ext in '' $ac_executable_extensions; do
8152   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8153     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8154     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8155     break 2
8156   fi
8157 done
8158 done
8159
8160 fi
8161 fi
8162 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8163 if test -n "$CC_FOR_TARGET"; then
8164   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8165 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8166 else
8167   echo "$as_me:$LINENO: result: no" >&5
8168 echo "${ECHO_T}no" >&6
8169 fi
8170
8171   done
8172 fi
8173
8174 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8175   for ncn_progname in cc gcc; do
8176     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8177 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8178     if test -x $with_build_time_tools/${ncn_progname}; then
8179       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8180       echo "$as_me:$LINENO: result: yes" >&5
8181 echo "${ECHO_T}yes" >&6
8182       break
8183     else
8184       echo "$as_me:$LINENO: result: no" >&5
8185 echo "${ECHO_T}no" >&6
8186     fi
8187   done
8188 fi
8189
8190 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8191   for ncn_progname in cc gcc; do
8192     if test -n "$ncn_target_tool_prefix"; then
8193       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8194 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8195 echo "$as_me:$LINENO: checking for $ac_word" >&5
8196 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8197 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8198   echo $ECHO_N "(cached) $ECHO_C" >&6
8199 else
8200   if test -n "$CC_FOR_TARGET"; then
8201   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8202 else
8203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8204 for as_dir in $PATH
8205 do
8206   IFS=$as_save_IFS
8207   test -z "$as_dir" && as_dir=.
8208   for ac_exec_ext in '' $ac_executable_extensions; do
8209   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8210     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8211     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8212     break 2
8213   fi
8214 done
8215 done
8216
8217 fi
8218 fi
8219 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8220 if test -n "$CC_FOR_TARGET"; then
8221   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8222 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8223 else
8224   echo "$as_me:$LINENO: result: no" >&5
8225 echo "${ECHO_T}no" >&6
8226 fi
8227
8228     fi
8229     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8230       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8231 set dummy ${ncn_progname}; ac_word=$2
8232 echo "$as_me:$LINENO: checking for $ac_word" >&5
8233 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8234 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8235   echo $ECHO_N "(cached) $ECHO_C" >&6
8236 else
8237   if test -n "$CC_FOR_TARGET"; then
8238   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8239 else
8240 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8241 for as_dir in $PATH
8242 do
8243   IFS=$as_save_IFS
8244   test -z "$as_dir" && as_dir=.
8245   for ac_exec_ext in '' $ac_executable_extensions; do
8246   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8247     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8248     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8249     break 2
8250   fi
8251 done
8252 done
8253
8254 fi
8255 fi
8256 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8257 if test -n "$CC_FOR_TARGET"; then
8258   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8259 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8260 else
8261   echo "$as_me:$LINENO: result: no" >&5
8262 echo "${ECHO_T}no" >&6
8263 fi
8264
8265     fi
8266     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8267   done
8268 fi
8269
8270 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8271   set dummy cc gcc
8272   if test $build = $target ; then
8273     CC_FOR_TARGET="$2"
8274   else
8275     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8276   fi
8277 else
8278   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8279 fi
8280
8281
8282
8283 if test -n "$CXX_FOR_TARGET"; then
8284   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8285 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8286   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8287 fi
8288
8289 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8290   for ncn_progname in c++ g++ cxx gxx; do
8291     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8292 set dummy ${ncn_progname}; ac_word=$2
8293 echo "$as_me:$LINENO: checking for $ac_word" >&5
8294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8295 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8296   echo $ECHO_N "(cached) $ECHO_C" >&6
8297 else
8298   if test -n "$CXX_FOR_TARGET"; then
8299   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8300 else
8301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8302 for as_dir in $PATH
8303 do
8304   IFS=$as_save_IFS
8305   test -z "$as_dir" && as_dir=.
8306   for ac_exec_ext in '' $ac_executable_extensions; do
8307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8308     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8310     break 2
8311   fi
8312 done
8313 done
8314
8315 fi
8316 fi
8317 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8318 if test -n "$CXX_FOR_TARGET"; then
8319   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8320 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8321 else
8322   echo "$as_me:$LINENO: result: no" >&5
8323 echo "${ECHO_T}no" >&6
8324 fi
8325
8326   done
8327 fi
8328
8329 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8330   for ncn_progname in c++ g++ cxx gxx; do
8331     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8332 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8333     if test -x $with_build_time_tools/${ncn_progname}; then
8334       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8335       echo "$as_me:$LINENO: result: yes" >&5
8336 echo "${ECHO_T}yes" >&6
8337       break
8338     else
8339       echo "$as_me:$LINENO: result: no" >&5
8340 echo "${ECHO_T}no" >&6
8341     fi
8342   done
8343 fi
8344
8345 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8346   for ncn_progname in c++ g++ cxx gxx; do
8347     if test -n "$ncn_target_tool_prefix"; then
8348       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8349 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8350 echo "$as_me:$LINENO: checking for $ac_word" >&5
8351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8352 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8353   echo $ECHO_N "(cached) $ECHO_C" >&6
8354 else
8355   if test -n "$CXX_FOR_TARGET"; then
8356   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8357 else
8358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8359 for as_dir in $PATH
8360 do
8361   IFS=$as_save_IFS
8362   test -z "$as_dir" && as_dir=.
8363   for ac_exec_ext in '' $ac_executable_extensions; do
8364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8365     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8367     break 2
8368   fi
8369 done
8370 done
8371
8372 fi
8373 fi
8374 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8375 if test -n "$CXX_FOR_TARGET"; then
8376   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8377 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8378 else
8379   echo "$as_me:$LINENO: result: no" >&5
8380 echo "${ECHO_T}no" >&6
8381 fi
8382
8383     fi
8384     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8385       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8386 set dummy ${ncn_progname}; ac_word=$2
8387 echo "$as_me:$LINENO: checking for $ac_word" >&5
8388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8389 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8390   echo $ECHO_N "(cached) $ECHO_C" >&6
8391 else
8392   if test -n "$CXX_FOR_TARGET"; then
8393   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8394 else
8395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8396 for as_dir in $PATH
8397 do
8398   IFS=$as_save_IFS
8399   test -z "$as_dir" && as_dir=.
8400   for ac_exec_ext in '' $ac_executable_extensions; do
8401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8402     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8404     break 2
8405   fi
8406 done
8407 done
8408
8409 fi
8410 fi
8411 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8412 if test -n "$CXX_FOR_TARGET"; then
8413   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8414 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8415 else
8416   echo "$as_me:$LINENO: result: no" >&5
8417 echo "${ECHO_T}no" >&6
8418 fi
8419
8420     fi
8421     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8422   done
8423 fi
8424
8425 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8426   set dummy c++ g++ cxx gxx
8427   if test $build = $target ; then
8428     CXX_FOR_TARGET="$2"
8429   else
8430     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8431   fi
8432 else
8433   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8434 fi
8435
8436
8437
8438 if test -n "$GCC_FOR_TARGET"; then
8439   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8440 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8441   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8442 fi
8443
8444 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8445   for ncn_progname in gcc; do
8446     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8447 set dummy ${ncn_progname}; ac_word=$2
8448 echo "$as_me:$LINENO: checking for $ac_word" >&5
8449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8450 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8451   echo $ECHO_N "(cached) $ECHO_C" >&6
8452 else
8453   if test -n "$GCC_FOR_TARGET"; then
8454   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8455 else
8456 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8457 for as_dir in $PATH
8458 do
8459   IFS=$as_save_IFS
8460   test -z "$as_dir" && as_dir=.
8461   for ac_exec_ext in '' $ac_executable_extensions; do
8462   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8463     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8464     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8465     break 2
8466   fi
8467 done
8468 done
8469
8470 fi
8471 fi
8472 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8473 if test -n "$GCC_FOR_TARGET"; then
8474   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8475 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8476 else
8477   echo "$as_me:$LINENO: result: no" >&5
8478 echo "${ECHO_T}no" >&6
8479 fi
8480
8481   done
8482 fi
8483
8484 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8485   for ncn_progname in gcc; do
8486     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8487 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8488     if test -x $with_build_time_tools/${ncn_progname}; then
8489       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8490       echo "$as_me:$LINENO: result: yes" >&5
8491 echo "${ECHO_T}yes" >&6
8492       break
8493     else
8494       echo "$as_me:$LINENO: result: no" >&5
8495 echo "${ECHO_T}no" >&6
8496     fi
8497   done
8498 fi
8499
8500 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8501   for ncn_progname in gcc; do
8502     if test -n "$ncn_target_tool_prefix"; then
8503       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8504 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8505 echo "$as_me:$LINENO: checking for $ac_word" >&5
8506 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8507 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8508   echo $ECHO_N "(cached) $ECHO_C" >&6
8509 else
8510   if test -n "$GCC_FOR_TARGET"; then
8511   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8512 else
8513 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8514 for as_dir in $PATH
8515 do
8516   IFS=$as_save_IFS
8517   test -z "$as_dir" && as_dir=.
8518   for ac_exec_ext in '' $ac_executable_extensions; do
8519   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8520     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8521     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8522     break 2
8523   fi
8524 done
8525 done
8526
8527 fi
8528 fi
8529 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8530 if test -n "$GCC_FOR_TARGET"; then
8531   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8532 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8533 else
8534   echo "$as_me:$LINENO: result: no" >&5
8535 echo "${ECHO_T}no" >&6
8536 fi
8537
8538     fi
8539     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8540       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8541 set dummy ${ncn_progname}; ac_word=$2
8542 echo "$as_me:$LINENO: checking for $ac_word" >&5
8543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8544 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8545   echo $ECHO_N "(cached) $ECHO_C" >&6
8546 else
8547   if test -n "$GCC_FOR_TARGET"; then
8548   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8549 else
8550 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8551 for as_dir in $PATH
8552 do
8553   IFS=$as_save_IFS
8554   test -z "$as_dir" && as_dir=.
8555   for ac_exec_ext in '' $ac_executable_extensions; do
8556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8557     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8559     break 2
8560   fi
8561 done
8562 done
8563
8564 fi
8565 fi
8566 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8567 if test -n "$GCC_FOR_TARGET"; then
8568   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8569 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8570 else
8571   echo "$as_me:$LINENO: result: no" >&5
8572 echo "${ECHO_T}no" >&6
8573 fi
8574
8575     fi
8576     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8577   done
8578 fi
8579
8580 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8581   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8582 else
8583   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8584 fi
8585
8586
8587
8588 if test -n "$GCJ_FOR_TARGET"; then
8589   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8590 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8591   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8592 fi
8593
8594 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8595   for ncn_progname in gcj; do
8596     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8597 set dummy ${ncn_progname}; ac_word=$2
8598 echo "$as_me:$LINENO: checking for $ac_word" >&5
8599 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8600 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8601   echo $ECHO_N "(cached) $ECHO_C" >&6
8602 else
8603   if test -n "$GCJ_FOR_TARGET"; then
8604   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8605 else
8606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8607 for as_dir in $PATH
8608 do
8609   IFS=$as_save_IFS
8610   test -z "$as_dir" && as_dir=.
8611   for ac_exec_ext in '' $ac_executable_extensions; do
8612   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8613     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8614     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8615     break 2
8616   fi
8617 done
8618 done
8619
8620 fi
8621 fi
8622 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8623 if test -n "$GCJ_FOR_TARGET"; then
8624   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8625 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8626 else
8627   echo "$as_me:$LINENO: result: no" >&5
8628 echo "${ECHO_T}no" >&6
8629 fi
8630
8631   done
8632 fi
8633
8634 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8635   for ncn_progname in gcj; do
8636     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8637 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8638     if test -x $with_build_time_tools/${ncn_progname}; then
8639       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8640       echo "$as_me:$LINENO: result: yes" >&5
8641 echo "${ECHO_T}yes" >&6
8642       break
8643     else
8644       echo "$as_me:$LINENO: result: no" >&5
8645 echo "${ECHO_T}no" >&6
8646     fi
8647   done
8648 fi
8649
8650 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8651   for ncn_progname in gcj; do
8652     if test -n "$ncn_target_tool_prefix"; then
8653       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8654 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8655 echo "$as_me:$LINENO: checking for $ac_word" >&5
8656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8657 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8658   echo $ECHO_N "(cached) $ECHO_C" >&6
8659 else
8660   if test -n "$GCJ_FOR_TARGET"; then
8661   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8662 else
8663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8664 for as_dir in $PATH
8665 do
8666   IFS=$as_save_IFS
8667   test -z "$as_dir" && as_dir=.
8668   for ac_exec_ext in '' $ac_executable_extensions; do
8669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8670     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8672     break 2
8673   fi
8674 done
8675 done
8676
8677 fi
8678 fi
8679 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8680 if test -n "$GCJ_FOR_TARGET"; then
8681   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8682 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8683 else
8684   echo "$as_me:$LINENO: result: no" >&5
8685 echo "${ECHO_T}no" >&6
8686 fi
8687
8688     fi
8689     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8690       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8691 set dummy ${ncn_progname}; ac_word=$2
8692 echo "$as_me:$LINENO: checking for $ac_word" >&5
8693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8694 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8695   echo $ECHO_N "(cached) $ECHO_C" >&6
8696 else
8697   if test -n "$GCJ_FOR_TARGET"; then
8698   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8699 else
8700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8701 for as_dir in $PATH
8702 do
8703   IFS=$as_save_IFS
8704   test -z "$as_dir" && as_dir=.
8705   for ac_exec_ext in '' $ac_executable_extensions; do
8706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8707     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8709     break 2
8710   fi
8711 done
8712 done
8713
8714 fi
8715 fi
8716 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8717 if test -n "$GCJ_FOR_TARGET"; then
8718   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8719 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8720 else
8721   echo "$as_me:$LINENO: result: no" >&5
8722 echo "${ECHO_T}no" >&6
8723 fi
8724
8725     fi
8726     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8727   done
8728 fi
8729
8730 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8731   set dummy gcj
8732   if test $build = $target ; then
8733     GCJ_FOR_TARGET="$2"
8734   else
8735     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8736   fi
8737 else
8738   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8739 fi
8740
8741
8742
8743 if test -n "$GFORTRAN_FOR_TARGET"; then
8744   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8745 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8746   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8747 fi
8748
8749 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8750   for ncn_progname in gfortran; do
8751     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8752 set dummy ${ncn_progname}; ac_word=$2
8753 echo "$as_me:$LINENO: checking for $ac_word" >&5
8754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8755 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8756   echo $ECHO_N "(cached) $ECHO_C" >&6
8757 else
8758   if test -n "$GFORTRAN_FOR_TARGET"; then
8759   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8760 else
8761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8762 for as_dir in $PATH
8763 do
8764   IFS=$as_save_IFS
8765   test -z "$as_dir" && as_dir=.
8766   for ac_exec_ext in '' $ac_executable_extensions; do
8767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8768     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8770     break 2
8771   fi
8772 done
8773 done
8774
8775 fi
8776 fi
8777 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8778 if test -n "$GFORTRAN_FOR_TARGET"; then
8779   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8780 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8781 else
8782   echo "$as_me:$LINENO: result: no" >&5
8783 echo "${ECHO_T}no" >&6
8784 fi
8785
8786   done
8787 fi
8788
8789 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8790   for ncn_progname in gfortran; do
8791     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8792 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8793     if test -x $with_build_time_tools/${ncn_progname}; then
8794       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8795       echo "$as_me:$LINENO: result: yes" >&5
8796 echo "${ECHO_T}yes" >&6
8797       break
8798     else
8799       echo "$as_me:$LINENO: result: no" >&5
8800 echo "${ECHO_T}no" >&6
8801     fi
8802   done
8803 fi
8804
8805 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8806   for ncn_progname in gfortran; do
8807     if test -n "$ncn_target_tool_prefix"; then
8808       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8809 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8810 echo "$as_me:$LINENO: checking for $ac_word" >&5
8811 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8812 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8813   echo $ECHO_N "(cached) $ECHO_C" >&6
8814 else
8815   if test -n "$GFORTRAN_FOR_TARGET"; then
8816   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8817 else
8818 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8819 for as_dir in $PATH
8820 do
8821   IFS=$as_save_IFS
8822   test -z "$as_dir" && as_dir=.
8823   for ac_exec_ext in '' $ac_executable_extensions; do
8824   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8825     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8826     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8827     break 2
8828   fi
8829 done
8830 done
8831
8832 fi
8833 fi
8834 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8835 if test -n "$GFORTRAN_FOR_TARGET"; then
8836   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8837 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8838 else
8839   echo "$as_me:$LINENO: result: no" >&5
8840 echo "${ECHO_T}no" >&6
8841 fi
8842
8843     fi
8844     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8845       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8846 set dummy ${ncn_progname}; ac_word=$2
8847 echo "$as_me:$LINENO: checking for $ac_word" >&5
8848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8849 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8850   echo $ECHO_N "(cached) $ECHO_C" >&6
8851 else
8852   if test -n "$GFORTRAN_FOR_TARGET"; then
8853   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8854 else
8855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8856 for as_dir in $PATH
8857 do
8858   IFS=$as_save_IFS
8859   test -z "$as_dir" && as_dir=.
8860   for ac_exec_ext in '' $ac_executable_extensions; do
8861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8862     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8864     break 2
8865   fi
8866 done
8867 done
8868
8869 fi
8870 fi
8871 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8872 if test -n "$GFORTRAN_FOR_TARGET"; then
8873   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8874 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8875 else
8876   echo "$as_me:$LINENO: result: no" >&5
8877 echo "${ECHO_T}no" >&6
8878 fi
8879
8880     fi
8881     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8882   done
8883 fi
8884
8885 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8886   set dummy gfortran
8887   if test $build = $target ; then
8888     GFORTRAN_FOR_TARGET="$2"
8889   else
8890     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8891   fi
8892 else
8893   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8894 fi
8895
8896
8897
8898 cat > conftest.c << \EOF
8899 #ifdef __GNUC__
8900   gcc_yay;
8901 #endif
8902 EOF
8903 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8904   have_gcc_for_target=yes
8905 else
8906   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8907   have_gcc_for_target=no
8908 fi
8909 rm conftest.c
8910
8911
8912
8913
8914 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8915   if test -n "$with_build_time_tools"; then
8916     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8917 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8918     if test -x $with_build_time_tools/ar; then
8919       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8920       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8921       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8922 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8923     else
8924       echo "$as_me:$LINENO: result: no" >&5
8925 echo "${ECHO_T}no" >&6
8926     fi
8927   elif test $build != $host && test $have_gcc_for_target = yes; then
8928     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8929     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8930     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8931   fi
8932 fi
8933 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8934   # Extract the first word of "ar", so it can be a program name with args.
8935 set dummy ar; ac_word=$2
8936 echo "$as_me:$LINENO: checking for $ac_word" >&5
8937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8938 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8939   echo $ECHO_N "(cached) $ECHO_C" >&6
8940 else
8941   case $AR_FOR_TARGET in
8942   [\\/]* | ?:[\\/]*)
8943   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8944   ;;
8945   *)
8946   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8947 for as_dir in $gcc_cv_tool_dirs
8948 do
8949   IFS=$as_save_IFS
8950   test -z "$as_dir" && as_dir=.
8951   for ac_exec_ext in '' $ac_executable_extensions; do
8952   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8953     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8954     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8955     break 2
8956   fi
8957 done
8958 done
8959
8960   ;;
8961 esac
8962 fi
8963 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8964
8965 if test -n "$AR_FOR_TARGET"; then
8966   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8967 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8968 else
8969   echo "$as_me:$LINENO: result: no" >&5
8970 echo "${ECHO_T}no" >&6
8971 fi
8972
8973 fi
8974 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8975
8976
8977 if test -n "$AR_FOR_TARGET"; then
8978   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8979 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8980   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8981 fi
8982
8983 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8984   for ncn_progname in ar; do
8985     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8986 set dummy ${ncn_progname}; ac_word=$2
8987 echo "$as_me:$LINENO: checking for $ac_word" >&5
8988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8989 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8990   echo $ECHO_N "(cached) $ECHO_C" >&6
8991 else
8992   if test -n "$AR_FOR_TARGET"; then
8993   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8994 else
8995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8996 for as_dir in $PATH
8997 do
8998   IFS=$as_save_IFS
8999   test -z "$as_dir" && as_dir=.
9000   for ac_exec_ext in '' $ac_executable_extensions; do
9001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9002     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9004     break 2
9005   fi
9006 done
9007 done
9008
9009 fi
9010 fi
9011 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9012 if test -n "$AR_FOR_TARGET"; then
9013   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9014 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9015 else
9016   echo "$as_me:$LINENO: result: no" >&5
9017 echo "${ECHO_T}no" >&6
9018 fi
9019
9020   done
9021 fi
9022
9023 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9024   for ncn_progname in ar; do
9025     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9026 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9027     if test -x $with_build_time_tools/${ncn_progname}; then
9028       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9029       echo "$as_me:$LINENO: result: yes" >&5
9030 echo "${ECHO_T}yes" >&6
9031       break
9032     else
9033       echo "$as_me:$LINENO: result: no" >&5
9034 echo "${ECHO_T}no" >&6
9035     fi
9036   done
9037 fi
9038
9039 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9040   for ncn_progname in ar; do
9041     if test -n "$ncn_target_tool_prefix"; then
9042       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9043 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9044 echo "$as_me:$LINENO: checking for $ac_word" >&5
9045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9046 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9047   echo $ECHO_N "(cached) $ECHO_C" >&6
9048 else
9049   if test -n "$AR_FOR_TARGET"; then
9050   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9051 else
9052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9053 for as_dir in $PATH
9054 do
9055   IFS=$as_save_IFS
9056   test -z "$as_dir" && as_dir=.
9057   for ac_exec_ext in '' $ac_executable_extensions; do
9058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9059     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9061     break 2
9062   fi
9063 done
9064 done
9065
9066 fi
9067 fi
9068 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9069 if test -n "$AR_FOR_TARGET"; then
9070   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9071 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9072 else
9073   echo "$as_me:$LINENO: result: no" >&5
9074 echo "${ECHO_T}no" >&6
9075 fi
9076
9077     fi
9078     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9079       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9080 set dummy ${ncn_progname}; ac_word=$2
9081 echo "$as_me:$LINENO: checking for $ac_word" >&5
9082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9083 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9084   echo $ECHO_N "(cached) $ECHO_C" >&6
9085 else
9086   if test -n "$AR_FOR_TARGET"; then
9087   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9088 else
9089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9090 for as_dir in $PATH
9091 do
9092   IFS=$as_save_IFS
9093   test -z "$as_dir" && as_dir=.
9094   for ac_exec_ext in '' $ac_executable_extensions; do
9095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9096     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9098     break 2
9099   fi
9100 done
9101 done
9102
9103 fi
9104 fi
9105 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9106 if test -n "$AR_FOR_TARGET"; then
9107   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9108 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9109 else
9110   echo "$as_me:$LINENO: result: no" >&5
9111 echo "${ECHO_T}no" >&6
9112 fi
9113
9114     fi
9115     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9116   done
9117 fi
9118
9119 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9120   set dummy ar
9121   if test $build = $target ; then
9122     AR_FOR_TARGET="$2"
9123   else
9124     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9125   fi
9126 else
9127   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9128 fi
9129
9130 else
9131   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9132 fi
9133
9134
9135
9136
9137 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9138   if test -n "$with_build_time_tools"; then
9139     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9140 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9141     if test -x $with_build_time_tools/as; then
9142       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9143       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9144       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9145 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9146     else
9147       echo "$as_me:$LINENO: result: no" >&5
9148 echo "${ECHO_T}no" >&6
9149     fi
9150   elif test $build != $host && test $have_gcc_for_target = yes; then
9151     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9152     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9153     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9154   fi
9155 fi
9156 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9157   # Extract the first word of "as", so it can be a program name with args.
9158 set dummy as; ac_word=$2
9159 echo "$as_me:$LINENO: checking for $ac_word" >&5
9160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9161 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9162   echo $ECHO_N "(cached) $ECHO_C" >&6
9163 else
9164   case $AS_FOR_TARGET in
9165   [\\/]* | ?:[\\/]*)
9166   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9167   ;;
9168   *)
9169   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9170 for as_dir in $gcc_cv_tool_dirs
9171 do
9172   IFS=$as_save_IFS
9173   test -z "$as_dir" && as_dir=.
9174   for ac_exec_ext in '' $ac_executable_extensions; do
9175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9176     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9178     break 2
9179   fi
9180 done
9181 done
9182
9183   ;;
9184 esac
9185 fi
9186 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9187
9188 if test -n "$AS_FOR_TARGET"; then
9189   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9190 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9191 else
9192   echo "$as_me:$LINENO: result: no" >&5
9193 echo "${ECHO_T}no" >&6
9194 fi
9195
9196 fi
9197 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9198
9199
9200 if test -n "$AS_FOR_TARGET"; then
9201   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9202 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9203   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9204 fi
9205
9206 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9207   for ncn_progname in as; do
9208     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9209 set dummy ${ncn_progname}; ac_word=$2
9210 echo "$as_me:$LINENO: checking for $ac_word" >&5
9211 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9212 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9213   echo $ECHO_N "(cached) $ECHO_C" >&6
9214 else
9215   if test -n "$AS_FOR_TARGET"; then
9216   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9217 else
9218 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9219 for as_dir in $PATH
9220 do
9221   IFS=$as_save_IFS
9222   test -z "$as_dir" && as_dir=.
9223   for ac_exec_ext in '' $ac_executable_extensions; do
9224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9225     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9227     break 2
9228   fi
9229 done
9230 done
9231
9232 fi
9233 fi
9234 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9235 if test -n "$AS_FOR_TARGET"; then
9236   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9237 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9238 else
9239   echo "$as_me:$LINENO: result: no" >&5
9240 echo "${ECHO_T}no" >&6
9241 fi
9242
9243   done
9244 fi
9245
9246 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9247   for ncn_progname in as; do
9248     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9249 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9250     if test -x $with_build_time_tools/${ncn_progname}; then
9251       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9252       echo "$as_me:$LINENO: result: yes" >&5
9253 echo "${ECHO_T}yes" >&6
9254       break
9255     else
9256       echo "$as_me:$LINENO: result: no" >&5
9257 echo "${ECHO_T}no" >&6
9258     fi
9259   done
9260 fi
9261
9262 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9263   for ncn_progname in as; do
9264     if test -n "$ncn_target_tool_prefix"; then
9265       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9266 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9267 echo "$as_me:$LINENO: checking for $ac_word" >&5
9268 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9269 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9270   echo $ECHO_N "(cached) $ECHO_C" >&6
9271 else
9272   if test -n "$AS_FOR_TARGET"; then
9273   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9274 else
9275 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9276 for as_dir in $PATH
9277 do
9278   IFS=$as_save_IFS
9279   test -z "$as_dir" && as_dir=.
9280   for ac_exec_ext in '' $ac_executable_extensions; do
9281   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9282     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9283     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9284     break 2
9285   fi
9286 done
9287 done
9288
9289 fi
9290 fi
9291 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9292 if test -n "$AS_FOR_TARGET"; then
9293   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9294 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9295 else
9296   echo "$as_me:$LINENO: result: no" >&5
9297 echo "${ECHO_T}no" >&6
9298 fi
9299
9300     fi
9301     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9302       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9303 set dummy ${ncn_progname}; ac_word=$2
9304 echo "$as_me:$LINENO: checking for $ac_word" >&5
9305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9306 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9307   echo $ECHO_N "(cached) $ECHO_C" >&6
9308 else
9309   if test -n "$AS_FOR_TARGET"; then
9310   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9311 else
9312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9313 for as_dir in $PATH
9314 do
9315   IFS=$as_save_IFS
9316   test -z "$as_dir" && as_dir=.
9317   for ac_exec_ext in '' $ac_executable_extensions; do
9318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9319     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9321     break 2
9322   fi
9323 done
9324 done
9325
9326 fi
9327 fi
9328 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9329 if test -n "$AS_FOR_TARGET"; then
9330   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9331 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9332 else
9333   echo "$as_me:$LINENO: result: no" >&5
9334 echo "${ECHO_T}no" >&6
9335 fi
9336
9337     fi
9338     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9339   done
9340 fi
9341
9342 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9343   set dummy as
9344   if test $build = $target ; then
9345     AS_FOR_TARGET="$2"
9346   else
9347     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9348   fi
9349 else
9350   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9351 fi
9352
9353 else
9354   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9355 fi
9356
9357
9358
9359
9360 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9361   if test -n "$with_build_time_tools"; then
9362     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9363 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9364     if test -x $with_build_time_tools/dlltool; then
9365       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9366       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9367       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9368 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9369     else
9370       echo "$as_me:$LINENO: result: no" >&5
9371 echo "${ECHO_T}no" >&6
9372     fi
9373   elif test $build != $host && test $have_gcc_for_target = yes; then
9374     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9375     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9376     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9377   fi
9378 fi
9379 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9380   # Extract the first word of "dlltool", so it can be a program name with args.
9381 set dummy dlltool; ac_word=$2
9382 echo "$as_me:$LINENO: checking for $ac_word" >&5
9383 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9384 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9385   echo $ECHO_N "(cached) $ECHO_C" >&6
9386 else
9387   case $DLLTOOL_FOR_TARGET in
9388   [\\/]* | ?:[\\/]*)
9389   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9390   ;;
9391   *)
9392   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9393 for as_dir in $gcc_cv_tool_dirs
9394 do
9395   IFS=$as_save_IFS
9396   test -z "$as_dir" && as_dir=.
9397   for ac_exec_ext in '' $ac_executable_extensions; do
9398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9399     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9401     break 2
9402   fi
9403 done
9404 done
9405
9406   ;;
9407 esac
9408 fi
9409 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9410
9411 if test -n "$DLLTOOL_FOR_TARGET"; then
9412   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9413 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9414 else
9415   echo "$as_me:$LINENO: result: no" >&5
9416 echo "${ECHO_T}no" >&6
9417 fi
9418
9419 fi
9420 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9421
9422
9423 if test -n "$DLLTOOL_FOR_TARGET"; then
9424   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9425 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9426   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9427 fi
9428
9429 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9430   for ncn_progname in dlltool; do
9431     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9432 set dummy ${ncn_progname}; ac_word=$2
9433 echo "$as_me:$LINENO: checking for $ac_word" >&5
9434 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9435 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9436   echo $ECHO_N "(cached) $ECHO_C" >&6
9437 else
9438   if test -n "$DLLTOOL_FOR_TARGET"; then
9439   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9440 else
9441 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9442 for as_dir in $PATH
9443 do
9444   IFS=$as_save_IFS
9445   test -z "$as_dir" && as_dir=.
9446   for ac_exec_ext in '' $ac_executable_extensions; do
9447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9448     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9450     break 2
9451   fi
9452 done
9453 done
9454
9455 fi
9456 fi
9457 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9458 if test -n "$DLLTOOL_FOR_TARGET"; then
9459   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9460 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9461 else
9462   echo "$as_me:$LINENO: result: no" >&5
9463 echo "${ECHO_T}no" >&6
9464 fi
9465
9466   done
9467 fi
9468
9469 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9470   for ncn_progname in dlltool; do
9471     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9472 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9473     if test -x $with_build_time_tools/${ncn_progname}; then
9474       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9475       echo "$as_me:$LINENO: result: yes" >&5
9476 echo "${ECHO_T}yes" >&6
9477       break
9478     else
9479       echo "$as_me:$LINENO: result: no" >&5
9480 echo "${ECHO_T}no" >&6
9481     fi
9482   done
9483 fi
9484
9485 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9486   for ncn_progname in dlltool; do
9487     if test -n "$ncn_target_tool_prefix"; then
9488       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9489 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9490 echo "$as_me:$LINENO: checking for $ac_word" >&5
9491 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9492 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9493   echo $ECHO_N "(cached) $ECHO_C" >&6
9494 else
9495   if test -n "$DLLTOOL_FOR_TARGET"; then
9496   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9497 else
9498 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9499 for as_dir in $PATH
9500 do
9501   IFS=$as_save_IFS
9502   test -z "$as_dir" && as_dir=.
9503   for ac_exec_ext in '' $ac_executable_extensions; do
9504   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9505     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9506     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9507     break 2
9508   fi
9509 done
9510 done
9511
9512 fi
9513 fi
9514 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9515 if test -n "$DLLTOOL_FOR_TARGET"; then
9516   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9517 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9518 else
9519   echo "$as_me:$LINENO: result: no" >&5
9520 echo "${ECHO_T}no" >&6
9521 fi
9522
9523     fi
9524     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9525       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9526 set dummy ${ncn_progname}; ac_word=$2
9527 echo "$as_me:$LINENO: checking for $ac_word" >&5
9528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9529 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9530   echo $ECHO_N "(cached) $ECHO_C" >&6
9531 else
9532   if test -n "$DLLTOOL_FOR_TARGET"; then
9533   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9534 else
9535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9536 for as_dir in $PATH
9537 do
9538   IFS=$as_save_IFS
9539   test -z "$as_dir" && as_dir=.
9540   for ac_exec_ext in '' $ac_executable_extensions; do
9541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9542     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9544     break 2
9545   fi
9546 done
9547 done
9548
9549 fi
9550 fi
9551 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9552 if test -n "$DLLTOOL_FOR_TARGET"; then
9553   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9554 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9555 else
9556   echo "$as_me:$LINENO: result: no" >&5
9557 echo "${ECHO_T}no" >&6
9558 fi
9559
9560     fi
9561     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9562   done
9563 fi
9564
9565 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9566   set dummy dlltool
9567   if test $build = $target ; then
9568     DLLTOOL_FOR_TARGET="$2"
9569   else
9570     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9571   fi
9572 else
9573   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9574 fi
9575
9576 else
9577   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9578 fi
9579
9580
9581
9582
9583 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9584   if test -n "$with_build_time_tools"; then
9585     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9586 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9587     if test -x $with_build_time_tools/ld; then
9588       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9589       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9590       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9591 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9592     else
9593       echo "$as_me:$LINENO: result: no" >&5
9594 echo "${ECHO_T}no" >&6
9595     fi
9596   elif test $build != $host && test $have_gcc_for_target = yes; then
9597     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9598     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9599     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9600   fi
9601 fi
9602 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9603   # Extract the first word of "ld", so it can be a program name with args.
9604 set dummy ld; ac_word=$2
9605 echo "$as_me:$LINENO: checking for $ac_word" >&5
9606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9607 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9608   echo $ECHO_N "(cached) $ECHO_C" >&6
9609 else
9610   case $LD_FOR_TARGET in
9611   [\\/]* | ?:[\\/]*)
9612   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9613   ;;
9614   *)
9615   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9616 for as_dir in $gcc_cv_tool_dirs
9617 do
9618   IFS=$as_save_IFS
9619   test -z "$as_dir" && as_dir=.
9620   for ac_exec_ext in '' $ac_executable_extensions; do
9621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9622     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9624     break 2
9625   fi
9626 done
9627 done
9628
9629   ;;
9630 esac
9631 fi
9632 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9633
9634 if test -n "$LD_FOR_TARGET"; then
9635   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9636 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9637 else
9638   echo "$as_me:$LINENO: result: no" >&5
9639 echo "${ECHO_T}no" >&6
9640 fi
9641
9642 fi
9643 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9644
9645
9646 if test -n "$LD_FOR_TARGET"; then
9647   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9648 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9649   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9650 fi
9651
9652 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9653   for ncn_progname in ld; do
9654     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9655 set dummy ${ncn_progname}; ac_word=$2
9656 echo "$as_me:$LINENO: checking for $ac_word" >&5
9657 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9658 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9659   echo $ECHO_N "(cached) $ECHO_C" >&6
9660 else
9661   if test -n "$LD_FOR_TARGET"; then
9662   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9663 else
9664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9665 for as_dir in $PATH
9666 do
9667   IFS=$as_save_IFS
9668   test -z "$as_dir" && as_dir=.
9669   for ac_exec_ext in '' $ac_executable_extensions; do
9670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9671     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9673     break 2
9674   fi
9675 done
9676 done
9677
9678 fi
9679 fi
9680 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9681 if test -n "$LD_FOR_TARGET"; then
9682   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9683 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9684 else
9685   echo "$as_me:$LINENO: result: no" >&5
9686 echo "${ECHO_T}no" >&6
9687 fi
9688
9689   done
9690 fi
9691
9692 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9693   for ncn_progname in ld; do
9694     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9695 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9696     if test -x $with_build_time_tools/${ncn_progname}; then
9697       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9698       echo "$as_me:$LINENO: result: yes" >&5
9699 echo "${ECHO_T}yes" >&6
9700       break
9701     else
9702       echo "$as_me:$LINENO: result: no" >&5
9703 echo "${ECHO_T}no" >&6
9704     fi
9705   done
9706 fi
9707
9708 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9709   for ncn_progname in ld; do
9710     if test -n "$ncn_target_tool_prefix"; then
9711       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9712 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9713 echo "$as_me:$LINENO: checking for $ac_word" >&5
9714 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9715 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9716   echo $ECHO_N "(cached) $ECHO_C" >&6
9717 else
9718   if test -n "$LD_FOR_TARGET"; then
9719   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9720 else
9721 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9722 for as_dir in $PATH
9723 do
9724   IFS=$as_save_IFS
9725   test -z "$as_dir" && as_dir=.
9726   for ac_exec_ext in '' $ac_executable_extensions; do
9727   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9728     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9729     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9730     break 2
9731   fi
9732 done
9733 done
9734
9735 fi
9736 fi
9737 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9738 if test -n "$LD_FOR_TARGET"; then
9739   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9740 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9741 else
9742   echo "$as_me:$LINENO: result: no" >&5
9743 echo "${ECHO_T}no" >&6
9744 fi
9745
9746     fi
9747     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9748       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9749 set dummy ${ncn_progname}; ac_word=$2
9750 echo "$as_me:$LINENO: checking for $ac_word" >&5
9751 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9752 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9753   echo $ECHO_N "(cached) $ECHO_C" >&6
9754 else
9755   if test -n "$LD_FOR_TARGET"; then
9756   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9757 else
9758 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9759 for as_dir in $PATH
9760 do
9761   IFS=$as_save_IFS
9762   test -z "$as_dir" && as_dir=.
9763   for ac_exec_ext in '' $ac_executable_extensions; do
9764   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9765     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9766     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9767     break 2
9768   fi
9769 done
9770 done
9771
9772 fi
9773 fi
9774 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9775 if test -n "$LD_FOR_TARGET"; then
9776   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9777 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9778 else
9779   echo "$as_me:$LINENO: result: no" >&5
9780 echo "${ECHO_T}no" >&6
9781 fi
9782
9783     fi
9784     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9785   done
9786 fi
9787
9788 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9789   set dummy ld
9790   if test $build = $target ; then
9791     LD_FOR_TARGET="$2"
9792   else
9793     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9794   fi
9795 else
9796   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9797 fi
9798
9799 else
9800   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9801 fi
9802
9803
9804
9805
9806 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9807   if test -n "$with_build_time_tools"; then
9808     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9809 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9810     if test -x $with_build_time_tools/lipo; then
9811       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9812       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9813       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9814 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9815     else
9816       echo "$as_me:$LINENO: result: no" >&5
9817 echo "${ECHO_T}no" >&6
9818     fi
9819   elif test $build != $host && test $have_gcc_for_target = yes; then
9820     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9821     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9822     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9823   fi
9824 fi
9825 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9826   # Extract the first word of "lipo", so it can be a program name with args.
9827 set dummy lipo; ac_word=$2
9828 echo "$as_me:$LINENO: checking for $ac_word" >&5
9829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9830 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9831   echo $ECHO_N "(cached) $ECHO_C" >&6
9832 else
9833   case $LIPO_FOR_TARGET in
9834   [\\/]* | ?:[\\/]*)
9835   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9836   ;;
9837   *)
9838   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9839 for as_dir in $gcc_cv_tool_dirs
9840 do
9841   IFS=$as_save_IFS
9842   test -z "$as_dir" && as_dir=.
9843   for ac_exec_ext in '' $ac_executable_extensions; do
9844   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9845     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9846     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9847     break 2
9848   fi
9849 done
9850 done
9851
9852   ;;
9853 esac
9854 fi
9855 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9856
9857 if test -n "$LIPO_FOR_TARGET"; then
9858   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9859 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9860 else
9861   echo "$as_me:$LINENO: result: no" >&5
9862 echo "${ECHO_T}no" >&6
9863 fi
9864
9865 fi
9866 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9867
9868
9869 if test -n "$LIPO_FOR_TARGET"; then
9870   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9871 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9872   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9873 fi
9874
9875 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9876   for ncn_progname in lipo; do
9877     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9878 set dummy ${ncn_progname}; ac_word=$2
9879 echo "$as_me:$LINENO: checking for $ac_word" >&5
9880 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9881 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9882   echo $ECHO_N "(cached) $ECHO_C" >&6
9883 else
9884   if test -n "$LIPO_FOR_TARGET"; then
9885   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9886 else
9887 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9888 for as_dir in $PATH
9889 do
9890   IFS=$as_save_IFS
9891   test -z "$as_dir" && as_dir=.
9892   for ac_exec_ext in '' $ac_executable_extensions; do
9893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9894     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9896     break 2
9897   fi
9898 done
9899 done
9900
9901 fi
9902 fi
9903 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9904 if test -n "$LIPO_FOR_TARGET"; then
9905   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9906 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9907 else
9908   echo "$as_me:$LINENO: result: no" >&5
9909 echo "${ECHO_T}no" >&6
9910 fi
9911
9912   done
9913 fi
9914
9915 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9916   for ncn_progname in lipo; do
9917     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9918 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9919     if test -x $with_build_time_tools/${ncn_progname}; then
9920       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9921       echo "$as_me:$LINENO: result: yes" >&5
9922 echo "${ECHO_T}yes" >&6
9923       break
9924     else
9925       echo "$as_me:$LINENO: result: no" >&5
9926 echo "${ECHO_T}no" >&6
9927     fi
9928   done
9929 fi
9930
9931 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9932   for ncn_progname in lipo; do
9933     if test -n "$ncn_target_tool_prefix"; then
9934       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9935 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9936 echo "$as_me:$LINENO: checking for $ac_word" >&5
9937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9938 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9939   echo $ECHO_N "(cached) $ECHO_C" >&6
9940 else
9941   if test -n "$LIPO_FOR_TARGET"; then
9942   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9943 else
9944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9945 for as_dir in $PATH
9946 do
9947   IFS=$as_save_IFS
9948   test -z "$as_dir" && as_dir=.
9949   for ac_exec_ext in '' $ac_executable_extensions; do
9950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9951     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9953     break 2
9954   fi
9955 done
9956 done
9957
9958 fi
9959 fi
9960 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9961 if test -n "$LIPO_FOR_TARGET"; then
9962   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9963 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9964 else
9965   echo "$as_me:$LINENO: result: no" >&5
9966 echo "${ECHO_T}no" >&6
9967 fi
9968
9969     fi
9970     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9971       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9972 set dummy ${ncn_progname}; ac_word=$2
9973 echo "$as_me:$LINENO: checking for $ac_word" >&5
9974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9975 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9976   echo $ECHO_N "(cached) $ECHO_C" >&6
9977 else
9978   if test -n "$LIPO_FOR_TARGET"; then
9979   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9980 else
9981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9982 for as_dir in $PATH
9983 do
9984   IFS=$as_save_IFS
9985   test -z "$as_dir" && as_dir=.
9986   for ac_exec_ext in '' $ac_executable_extensions; do
9987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9988     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9990     break 2
9991   fi
9992 done
9993 done
9994
9995 fi
9996 fi
9997 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9998 if test -n "$LIPO_FOR_TARGET"; then
9999   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10000 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10001 else
10002   echo "$as_me:$LINENO: result: no" >&5
10003 echo "${ECHO_T}no" >&6
10004 fi
10005
10006     fi
10007     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10008   done
10009 fi
10010
10011 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10012   set dummy lipo
10013   if test $build = $target ; then
10014     LIPO_FOR_TARGET="$2"
10015   else
10016     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10017   fi
10018 else
10019   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10020 fi
10021
10022 else
10023   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10024 fi
10025
10026
10027
10028
10029 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10030   if test -n "$with_build_time_tools"; then
10031     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10032 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10033     if test -x $with_build_time_tools/nm; then
10034       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10035       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10036       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10037 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10038     else
10039       echo "$as_me:$LINENO: result: no" >&5
10040 echo "${ECHO_T}no" >&6
10041     fi
10042   elif test $build != $host && test $have_gcc_for_target = yes; then
10043     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10044     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10045     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10046   fi
10047 fi
10048 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10049   # Extract the first word of "nm", so it can be a program name with args.
10050 set dummy nm; ac_word=$2
10051 echo "$as_me:$LINENO: checking for $ac_word" >&5
10052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10053 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10054   echo $ECHO_N "(cached) $ECHO_C" >&6
10055 else
10056   case $NM_FOR_TARGET in
10057   [\\/]* | ?:[\\/]*)
10058   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10059   ;;
10060   *)
10061   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10062 for as_dir in $gcc_cv_tool_dirs
10063 do
10064   IFS=$as_save_IFS
10065   test -z "$as_dir" && as_dir=.
10066   for ac_exec_ext in '' $ac_executable_extensions; do
10067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10068     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10070     break 2
10071   fi
10072 done
10073 done
10074
10075   ;;
10076 esac
10077 fi
10078 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10079
10080 if test -n "$NM_FOR_TARGET"; then
10081   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10082 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10083 else
10084   echo "$as_me:$LINENO: result: no" >&5
10085 echo "${ECHO_T}no" >&6
10086 fi
10087
10088 fi
10089 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10090
10091
10092 if test -n "$NM_FOR_TARGET"; then
10093   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10094 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10095   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10096 fi
10097
10098 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10099   for ncn_progname in nm; do
10100     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10101 set dummy ${ncn_progname}; ac_word=$2
10102 echo "$as_me:$LINENO: checking for $ac_word" >&5
10103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10104 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10105   echo $ECHO_N "(cached) $ECHO_C" >&6
10106 else
10107   if test -n "$NM_FOR_TARGET"; then
10108   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10109 else
10110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10111 for as_dir in $PATH
10112 do
10113   IFS=$as_save_IFS
10114   test -z "$as_dir" && as_dir=.
10115   for ac_exec_ext in '' $ac_executable_extensions; do
10116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10117     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10119     break 2
10120   fi
10121 done
10122 done
10123
10124 fi
10125 fi
10126 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10127 if test -n "$NM_FOR_TARGET"; then
10128   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10129 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10130 else
10131   echo "$as_me:$LINENO: result: no" >&5
10132 echo "${ECHO_T}no" >&6
10133 fi
10134
10135   done
10136 fi
10137
10138 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10139   for ncn_progname in nm; do
10140     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10141 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10142     if test -x $with_build_time_tools/${ncn_progname}; then
10143       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10144       echo "$as_me:$LINENO: result: yes" >&5
10145 echo "${ECHO_T}yes" >&6
10146       break
10147     else
10148       echo "$as_me:$LINENO: result: no" >&5
10149 echo "${ECHO_T}no" >&6
10150     fi
10151   done
10152 fi
10153
10154 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10155   for ncn_progname in nm; do
10156     if test -n "$ncn_target_tool_prefix"; then
10157       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10158 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10159 echo "$as_me:$LINENO: checking for $ac_word" >&5
10160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10161 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10162   echo $ECHO_N "(cached) $ECHO_C" >&6
10163 else
10164   if test -n "$NM_FOR_TARGET"; then
10165   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10166 else
10167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10168 for as_dir in $PATH
10169 do
10170   IFS=$as_save_IFS
10171   test -z "$as_dir" && as_dir=.
10172   for ac_exec_ext in '' $ac_executable_extensions; do
10173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10174     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10176     break 2
10177   fi
10178 done
10179 done
10180
10181 fi
10182 fi
10183 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10184 if test -n "$NM_FOR_TARGET"; then
10185   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10186 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10187 else
10188   echo "$as_me:$LINENO: result: no" >&5
10189 echo "${ECHO_T}no" >&6
10190 fi
10191
10192     fi
10193     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10194       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10195 set dummy ${ncn_progname}; ac_word=$2
10196 echo "$as_me:$LINENO: checking for $ac_word" >&5
10197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10198 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10199   echo $ECHO_N "(cached) $ECHO_C" >&6
10200 else
10201   if test -n "$NM_FOR_TARGET"; then
10202   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10203 else
10204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10205 for as_dir in $PATH
10206 do
10207   IFS=$as_save_IFS
10208   test -z "$as_dir" && as_dir=.
10209   for ac_exec_ext in '' $ac_executable_extensions; do
10210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10211     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10213     break 2
10214   fi
10215 done
10216 done
10217
10218 fi
10219 fi
10220 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10221 if test -n "$NM_FOR_TARGET"; then
10222   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10223 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10224 else
10225   echo "$as_me:$LINENO: result: no" >&5
10226 echo "${ECHO_T}no" >&6
10227 fi
10228
10229     fi
10230     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10231   done
10232 fi
10233
10234 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10235   set dummy nm
10236   if test $build = $target ; then
10237     NM_FOR_TARGET="$2"
10238   else
10239     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10240   fi
10241 else
10242   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10243 fi
10244
10245 else
10246   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10247 fi
10248
10249
10250
10251
10252 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10253   if test -n "$with_build_time_tools"; then
10254     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10255 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10256     if test -x $with_build_time_tools/objdump; then
10257       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10258       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10259       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10260 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10261     else
10262       echo "$as_me:$LINENO: result: no" >&5
10263 echo "${ECHO_T}no" >&6
10264     fi
10265   elif test $build != $host && test $have_gcc_for_target = yes; then
10266     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10267     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10268     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10269   fi
10270 fi
10271 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10272   # Extract the first word of "objdump", so it can be a program name with args.
10273 set dummy objdump; ac_word=$2
10274 echo "$as_me:$LINENO: checking for $ac_word" >&5
10275 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10276 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10277   echo $ECHO_N "(cached) $ECHO_C" >&6
10278 else
10279   case $OBJDUMP_FOR_TARGET in
10280   [\\/]* | ?:[\\/]*)
10281   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10282   ;;
10283   *)
10284   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10285 for as_dir in $gcc_cv_tool_dirs
10286 do
10287   IFS=$as_save_IFS
10288   test -z "$as_dir" && as_dir=.
10289   for ac_exec_ext in '' $ac_executable_extensions; do
10290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10291     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10293     break 2
10294   fi
10295 done
10296 done
10297
10298   ;;
10299 esac
10300 fi
10301 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10302
10303 if test -n "$OBJDUMP_FOR_TARGET"; then
10304   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10305 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10306 else
10307   echo "$as_me:$LINENO: result: no" >&5
10308 echo "${ECHO_T}no" >&6
10309 fi
10310
10311 fi
10312 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10313
10314
10315 if test -n "$OBJDUMP_FOR_TARGET"; then
10316   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10317 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10318   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10319 fi
10320
10321 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10322   for ncn_progname in objdump; do
10323     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10324 set dummy ${ncn_progname}; ac_word=$2
10325 echo "$as_me:$LINENO: checking for $ac_word" >&5
10326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10327 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10328   echo $ECHO_N "(cached) $ECHO_C" >&6
10329 else
10330   if test -n "$OBJDUMP_FOR_TARGET"; then
10331   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10332 else
10333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10334 for as_dir in $PATH
10335 do
10336   IFS=$as_save_IFS
10337   test -z "$as_dir" && as_dir=.
10338   for ac_exec_ext in '' $ac_executable_extensions; do
10339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10340     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10342     break 2
10343   fi
10344 done
10345 done
10346
10347 fi
10348 fi
10349 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10350 if test -n "$OBJDUMP_FOR_TARGET"; then
10351   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10352 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10353 else
10354   echo "$as_me:$LINENO: result: no" >&5
10355 echo "${ECHO_T}no" >&6
10356 fi
10357
10358   done
10359 fi
10360
10361 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10362   for ncn_progname in objdump; do
10363     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10364 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10365     if test -x $with_build_time_tools/${ncn_progname}; then
10366       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10367       echo "$as_me:$LINENO: result: yes" >&5
10368 echo "${ECHO_T}yes" >&6
10369       break
10370     else
10371       echo "$as_me:$LINENO: result: no" >&5
10372 echo "${ECHO_T}no" >&6
10373     fi
10374   done
10375 fi
10376
10377 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10378   for ncn_progname in objdump; do
10379     if test -n "$ncn_target_tool_prefix"; then
10380       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10381 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10382 echo "$as_me:$LINENO: checking for $ac_word" >&5
10383 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10384 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10385   echo $ECHO_N "(cached) $ECHO_C" >&6
10386 else
10387   if test -n "$OBJDUMP_FOR_TARGET"; then
10388   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10389 else
10390 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10391 for as_dir in $PATH
10392 do
10393   IFS=$as_save_IFS
10394   test -z "$as_dir" && as_dir=.
10395   for ac_exec_ext in '' $ac_executable_extensions; do
10396   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10397     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10398     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10399     break 2
10400   fi
10401 done
10402 done
10403
10404 fi
10405 fi
10406 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10407 if test -n "$OBJDUMP_FOR_TARGET"; then
10408   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10409 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10410 else
10411   echo "$as_me:$LINENO: result: no" >&5
10412 echo "${ECHO_T}no" >&6
10413 fi
10414
10415     fi
10416     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10417       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10418 set dummy ${ncn_progname}; ac_word=$2
10419 echo "$as_me:$LINENO: checking for $ac_word" >&5
10420 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10421 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10422   echo $ECHO_N "(cached) $ECHO_C" >&6
10423 else
10424   if test -n "$OBJDUMP_FOR_TARGET"; then
10425   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10426 else
10427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10428 for as_dir in $PATH
10429 do
10430   IFS=$as_save_IFS
10431   test -z "$as_dir" && as_dir=.
10432   for ac_exec_ext in '' $ac_executable_extensions; do
10433   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10434     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10435     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10436     break 2
10437   fi
10438 done
10439 done
10440
10441 fi
10442 fi
10443 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10444 if test -n "$OBJDUMP_FOR_TARGET"; then
10445   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10446 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10447 else
10448   echo "$as_me:$LINENO: result: no" >&5
10449 echo "${ECHO_T}no" >&6
10450 fi
10451
10452     fi
10453     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10454   done
10455 fi
10456
10457 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10458   set dummy objdump
10459   if test $build = $target ; then
10460     OBJDUMP_FOR_TARGET="$2"
10461   else
10462     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10463   fi
10464 else
10465   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10466 fi
10467
10468 else
10469   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10470 fi
10471
10472
10473
10474
10475 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10476   if test -n "$with_build_time_tools"; then
10477     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10478 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10479     if test -x $with_build_time_tools/ranlib; then
10480       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10481       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10482       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10483 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10484     else
10485       echo "$as_me:$LINENO: result: no" >&5
10486 echo "${ECHO_T}no" >&6
10487     fi
10488   elif test $build != $host && test $have_gcc_for_target = yes; then
10489     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10490     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10491     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10492   fi
10493 fi
10494 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10495   # Extract the first word of "ranlib", so it can be a program name with args.
10496 set dummy ranlib; ac_word=$2
10497 echo "$as_me:$LINENO: checking for $ac_word" >&5
10498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10499 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10500   echo $ECHO_N "(cached) $ECHO_C" >&6
10501 else
10502   case $RANLIB_FOR_TARGET in
10503   [\\/]* | ?:[\\/]*)
10504   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10505   ;;
10506   *)
10507   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10508 for as_dir in $gcc_cv_tool_dirs
10509 do
10510   IFS=$as_save_IFS
10511   test -z "$as_dir" && as_dir=.
10512   for ac_exec_ext in '' $ac_executable_extensions; do
10513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10514     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10516     break 2
10517   fi
10518 done
10519 done
10520
10521   ;;
10522 esac
10523 fi
10524 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10525
10526 if test -n "$RANLIB_FOR_TARGET"; then
10527   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10528 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10529 else
10530   echo "$as_me:$LINENO: result: no" >&5
10531 echo "${ECHO_T}no" >&6
10532 fi
10533
10534 fi
10535 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10536
10537
10538 if test -n "$RANLIB_FOR_TARGET"; then
10539   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10540 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10541   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10542 fi
10543
10544 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10545   for ncn_progname in ranlib; do
10546     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10547 set dummy ${ncn_progname}; ac_word=$2
10548 echo "$as_me:$LINENO: checking for $ac_word" >&5
10549 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10550 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10551   echo $ECHO_N "(cached) $ECHO_C" >&6
10552 else
10553   if test -n "$RANLIB_FOR_TARGET"; then
10554   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10555 else
10556 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10557 for as_dir in $PATH
10558 do
10559   IFS=$as_save_IFS
10560   test -z "$as_dir" && as_dir=.
10561   for ac_exec_ext in '' $ac_executable_extensions; do
10562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10563     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10565     break 2
10566   fi
10567 done
10568 done
10569
10570 fi
10571 fi
10572 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10573 if test -n "$RANLIB_FOR_TARGET"; then
10574   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10575 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10576 else
10577   echo "$as_me:$LINENO: result: no" >&5
10578 echo "${ECHO_T}no" >&6
10579 fi
10580
10581   done
10582 fi
10583
10584 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10585   for ncn_progname in ranlib; do
10586     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10587 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10588     if test -x $with_build_time_tools/${ncn_progname}; then
10589       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10590       echo "$as_me:$LINENO: result: yes" >&5
10591 echo "${ECHO_T}yes" >&6
10592       break
10593     else
10594       echo "$as_me:$LINENO: result: no" >&5
10595 echo "${ECHO_T}no" >&6
10596     fi
10597   done
10598 fi
10599
10600 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10601   for ncn_progname in ranlib; do
10602     if test -n "$ncn_target_tool_prefix"; then
10603       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10604 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10605 echo "$as_me:$LINENO: checking for $ac_word" >&5
10606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10607 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10608   echo $ECHO_N "(cached) $ECHO_C" >&6
10609 else
10610   if test -n "$RANLIB_FOR_TARGET"; then
10611   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10612 else
10613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10614 for as_dir in $PATH
10615 do
10616   IFS=$as_save_IFS
10617   test -z "$as_dir" && as_dir=.
10618   for ac_exec_ext in '' $ac_executable_extensions; do
10619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10620     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10622     break 2
10623   fi
10624 done
10625 done
10626
10627 fi
10628 fi
10629 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10630 if test -n "$RANLIB_FOR_TARGET"; then
10631   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10632 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10633 else
10634   echo "$as_me:$LINENO: result: no" >&5
10635 echo "${ECHO_T}no" >&6
10636 fi
10637
10638     fi
10639     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10640       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10641 set dummy ${ncn_progname}; ac_word=$2
10642 echo "$as_me:$LINENO: checking for $ac_word" >&5
10643 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10644 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10645   echo $ECHO_N "(cached) $ECHO_C" >&6
10646 else
10647   if test -n "$RANLIB_FOR_TARGET"; then
10648   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10649 else
10650 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10651 for as_dir in $PATH
10652 do
10653   IFS=$as_save_IFS
10654   test -z "$as_dir" && as_dir=.
10655   for ac_exec_ext in '' $ac_executable_extensions; do
10656   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10657     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10658     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10659     break 2
10660   fi
10661 done
10662 done
10663
10664 fi
10665 fi
10666 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10667 if test -n "$RANLIB_FOR_TARGET"; then
10668   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10669 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10670 else
10671   echo "$as_me:$LINENO: result: no" >&5
10672 echo "${ECHO_T}no" >&6
10673 fi
10674
10675     fi
10676     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10677   done
10678 fi
10679
10680 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10681   set dummy ranlib
10682   if test $build = $target ; then
10683     RANLIB_FOR_TARGET="$2"
10684   else
10685     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10686   fi
10687 else
10688   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10689 fi
10690
10691 else
10692   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10693 fi
10694
10695
10696
10697
10698 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10699   if test -n "$with_build_time_tools"; then
10700     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10701 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10702     if test -x $with_build_time_tools/strip; then
10703       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10704       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10705       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10706 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10707     else
10708       echo "$as_me:$LINENO: result: no" >&5
10709 echo "${ECHO_T}no" >&6
10710     fi
10711   elif test $build != $host && test $have_gcc_for_target = yes; then
10712     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10713     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10714     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10715   fi
10716 fi
10717 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10718   # Extract the first word of "strip", so it can be a program name with args.
10719 set dummy strip; ac_word=$2
10720 echo "$as_me:$LINENO: checking for $ac_word" >&5
10721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10722 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10723   echo $ECHO_N "(cached) $ECHO_C" >&6
10724 else
10725   case $STRIP_FOR_TARGET in
10726   [\\/]* | ?:[\\/]*)
10727   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10728   ;;
10729   *)
10730   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10731 for as_dir in $gcc_cv_tool_dirs
10732 do
10733   IFS=$as_save_IFS
10734   test -z "$as_dir" && as_dir=.
10735   for ac_exec_ext in '' $ac_executable_extensions; do
10736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10737     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10739     break 2
10740   fi
10741 done
10742 done
10743
10744   ;;
10745 esac
10746 fi
10747 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10748
10749 if test -n "$STRIP_FOR_TARGET"; then
10750   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10751 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10752 else
10753   echo "$as_me:$LINENO: result: no" >&5
10754 echo "${ECHO_T}no" >&6
10755 fi
10756
10757 fi
10758 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10759
10760
10761 if test -n "$STRIP_FOR_TARGET"; then
10762   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10763 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10764   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10765 fi
10766
10767 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10768   for ncn_progname in strip; do
10769     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10770 set dummy ${ncn_progname}; ac_word=$2
10771 echo "$as_me:$LINENO: checking for $ac_word" >&5
10772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10773 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10774   echo $ECHO_N "(cached) $ECHO_C" >&6
10775 else
10776   if test -n "$STRIP_FOR_TARGET"; then
10777   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10778 else
10779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10780 for as_dir in $PATH
10781 do
10782   IFS=$as_save_IFS
10783   test -z "$as_dir" && as_dir=.
10784   for ac_exec_ext in '' $ac_executable_extensions; do
10785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10786     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10788     break 2
10789   fi
10790 done
10791 done
10792
10793 fi
10794 fi
10795 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10796 if test -n "$STRIP_FOR_TARGET"; then
10797   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10798 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10799 else
10800   echo "$as_me:$LINENO: result: no" >&5
10801 echo "${ECHO_T}no" >&6
10802 fi
10803
10804   done
10805 fi
10806
10807 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10808   for ncn_progname in strip; do
10809     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10810 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10811     if test -x $with_build_time_tools/${ncn_progname}; then
10812       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10813       echo "$as_me:$LINENO: result: yes" >&5
10814 echo "${ECHO_T}yes" >&6
10815       break
10816     else
10817       echo "$as_me:$LINENO: result: no" >&5
10818 echo "${ECHO_T}no" >&6
10819     fi
10820   done
10821 fi
10822
10823 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10824   for ncn_progname in strip; do
10825     if test -n "$ncn_target_tool_prefix"; then
10826       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10827 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10828 echo "$as_me:$LINENO: checking for $ac_word" >&5
10829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10830 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10831   echo $ECHO_N "(cached) $ECHO_C" >&6
10832 else
10833   if test -n "$STRIP_FOR_TARGET"; then
10834   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10835 else
10836 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10837 for as_dir in $PATH
10838 do
10839   IFS=$as_save_IFS
10840   test -z "$as_dir" && as_dir=.
10841   for ac_exec_ext in '' $ac_executable_extensions; do
10842   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10843     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10844     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10845     break 2
10846   fi
10847 done
10848 done
10849
10850 fi
10851 fi
10852 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10853 if test -n "$STRIP_FOR_TARGET"; then
10854   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10855 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10856 else
10857   echo "$as_me:$LINENO: result: no" >&5
10858 echo "${ECHO_T}no" >&6
10859 fi
10860
10861     fi
10862     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10863       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10864 set dummy ${ncn_progname}; ac_word=$2
10865 echo "$as_me:$LINENO: checking for $ac_word" >&5
10866 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10867 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10868   echo $ECHO_N "(cached) $ECHO_C" >&6
10869 else
10870   if test -n "$STRIP_FOR_TARGET"; then
10871   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10872 else
10873 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10874 for as_dir in $PATH
10875 do
10876   IFS=$as_save_IFS
10877   test -z "$as_dir" && as_dir=.
10878   for ac_exec_ext in '' $ac_executable_extensions; do
10879   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10880     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10881     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10882     break 2
10883   fi
10884 done
10885 done
10886
10887 fi
10888 fi
10889 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10890 if test -n "$STRIP_FOR_TARGET"; then
10891   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10892 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10893 else
10894   echo "$as_me:$LINENO: result: no" >&5
10895 echo "${ECHO_T}no" >&6
10896 fi
10897
10898     fi
10899     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10900   done
10901 fi
10902
10903 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10904   set dummy strip
10905   if test $build = $target ; then
10906     STRIP_FOR_TARGET="$2"
10907   else
10908     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10909   fi
10910 else
10911   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10912 fi
10913
10914 else
10915   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10916 fi
10917
10918
10919
10920
10921 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10922   if test -n "$with_build_time_tools"; then
10923     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10924 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10925     if test -x $with_build_time_tools/windres; then
10926       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10927       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10928       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10929 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10930     else
10931       echo "$as_me:$LINENO: result: no" >&5
10932 echo "${ECHO_T}no" >&6
10933     fi
10934   elif test $build != $host && test $have_gcc_for_target = yes; then
10935     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10936     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10937     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10938   fi
10939 fi
10940 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10941   # Extract the first word of "windres", so it can be a program name with args.
10942 set dummy windres; ac_word=$2
10943 echo "$as_me:$LINENO: checking for $ac_word" >&5
10944 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10945 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10946   echo $ECHO_N "(cached) $ECHO_C" >&6
10947 else
10948   case $WINDRES_FOR_TARGET in
10949   [\\/]* | ?:[\\/]*)
10950   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10951   ;;
10952   *)
10953   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10954 for as_dir in $gcc_cv_tool_dirs
10955 do
10956   IFS=$as_save_IFS
10957   test -z "$as_dir" && as_dir=.
10958   for ac_exec_ext in '' $ac_executable_extensions; do
10959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10960     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10962     break 2
10963   fi
10964 done
10965 done
10966
10967   ;;
10968 esac
10969 fi
10970 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10971
10972 if test -n "$WINDRES_FOR_TARGET"; then
10973   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10974 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10975 else
10976   echo "$as_me:$LINENO: result: no" >&5
10977 echo "${ECHO_T}no" >&6
10978 fi
10979
10980 fi
10981 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10982
10983
10984 if test -n "$WINDRES_FOR_TARGET"; then
10985   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10986 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10987   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10988 fi
10989
10990 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10991   for ncn_progname in windres; do
10992     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10993 set dummy ${ncn_progname}; ac_word=$2
10994 echo "$as_me:$LINENO: checking for $ac_word" >&5
10995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10996 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10997   echo $ECHO_N "(cached) $ECHO_C" >&6
10998 else
10999   if test -n "$WINDRES_FOR_TARGET"; then
11000   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11001 else
11002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11003 for as_dir in $PATH
11004 do
11005   IFS=$as_save_IFS
11006   test -z "$as_dir" && as_dir=.
11007   for ac_exec_ext in '' $ac_executable_extensions; do
11008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11009     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11011     break 2
11012   fi
11013 done
11014 done
11015
11016 fi
11017 fi
11018 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11019 if test -n "$WINDRES_FOR_TARGET"; then
11020   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11021 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11022 else
11023   echo "$as_me:$LINENO: result: no" >&5
11024 echo "${ECHO_T}no" >&6
11025 fi
11026
11027   done
11028 fi
11029
11030 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11031   for ncn_progname in windres; do
11032     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11033 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11034     if test -x $with_build_time_tools/${ncn_progname}; then
11035       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11036       echo "$as_me:$LINENO: result: yes" >&5
11037 echo "${ECHO_T}yes" >&6
11038       break
11039     else
11040       echo "$as_me:$LINENO: result: no" >&5
11041 echo "${ECHO_T}no" >&6
11042     fi
11043   done
11044 fi
11045
11046 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11047   for ncn_progname in windres; do
11048     if test -n "$ncn_target_tool_prefix"; then
11049       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11050 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11051 echo "$as_me:$LINENO: checking for $ac_word" >&5
11052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11053 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11054   echo $ECHO_N "(cached) $ECHO_C" >&6
11055 else
11056   if test -n "$WINDRES_FOR_TARGET"; then
11057   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11058 else
11059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11060 for as_dir in $PATH
11061 do
11062   IFS=$as_save_IFS
11063   test -z "$as_dir" && as_dir=.
11064   for ac_exec_ext in '' $ac_executable_extensions; do
11065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11066     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11068     break 2
11069   fi
11070 done
11071 done
11072
11073 fi
11074 fi
11075 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11076 if test -n "$WINDRES_FOR_TARGET"; then
11077   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11078 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11079 else
11080   echo "$as_me:$LINENO: result: no" >&5
11081 echo "${ECHO_T}no" >&6
11082 fi
11083
11084     fi
11085     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11086       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11087 set dummy ${ncn_progname}; ac_word=$2
11088 echo "$as_me:$LINENO: checking for $ac_word" >&5
11089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11090 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11091   echo $ECHO_N "(cached) $ECHO_C" >&6
11092 else
11093   if test -n "$WINDRES_FOR_TARGET"; then
11094   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11095 else
11096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11097 for as_dir in $PATH
11098 do
11099   IFS=$as_save_IFS
11100   test -z "$as_dir" && as_dir=.
11101   for ac_exec_ext in '' $ac_executable_extensions; do
11102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11103     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11105     break 2
11106   fi
11107 done
11108 done
11109
11110 fi
11111 fi
11112 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11113 if test -n "$WINDRES_FOR_TARGET"; then
11114   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11115 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11116 else
11117   echo "$as_me:$LINENO: result: no" >&5
11118 echo "${ECHO_T}no" >&6
11119 fi
11120
11121     fi
11122     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11123   done
11124 fi
11125
11126 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11127   set dummy windres
11128   if test $build = $target ; then
11129     WINDRES_FOR_TARGET="$2"
11130   else
11131     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11132   fi
11133 else
11134   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11135 fi
11136
11137 else
11138   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11139 fi
11140
11141
11142
11143
11144 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11145   if test -n "$with_build_time_tools"; then
11146     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11147 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11148     if test -x $with_build_time_tools/windmc; then
11149       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11150       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11151       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11152 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11153     else
11154       echo "$as_me:$LINENO: result: no" >&5
11155 echo "${ECHO_T}no" >&6
11156     fi
11157   elif test $build != $host && test $have_gcc_for_target = yes; then
11158     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11159     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11160     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11161   fi
11162 fi
11163 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11164   # Extract the first word of "windmc", so it can be a program name with args.
11165 set dummy windmc; ac_word=$2
11166 echo "$as_me:$LINENO: checking for $ac_word" >&5
11167 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11168 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11169   echo $ECHO_N "(cached) $ECHO_C" >&6
11170 else
11171   case $WINDMC_FOR_TARGET in
11172   [\\/]* | ?:[\\/]*)
11173   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11174   ;;
11175   *)
11176   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11177 for as_dir in $gcc_cv_tool_dirs
11178 do
11179   IFS=$as_save_IFS
11180   test -z "$as_dir" && as_dir=.
11181   for ac_exec_ext in '' $ac_executable_extensions; do
11182   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11183     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11184     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11185     break 2
11186   fi
11187 done
11188 done
11189
11190   ;;
11191 esac
11192 fi
11193 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11194
11195 if test -n "$WINDMC_FOR_TARGET"; then
11196   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11197 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11198 else
11199   echo "$as_me:$LINENO: result: no" >&5
11200 echo "${ECHO_T}no" >&6
11201 fi
11202
11203 fi
11204 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11205
11206
11207 if test -n "$WINDMC_FOR_TARGET"; then
11208   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11209 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11210   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11211 fi
11212
11213 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11214   for ncn_progname in windmc; do
11215     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11216 set dummy ${ncn_progname}; ac_word=$2
11217 echo "$as_me:$LINENO: checking for $ac_word" >&5
11218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11219 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11220   echo $ECHO_N "(cached) $ECHO_C" >&6
11221 else
11222   if test -n "$WINDMC_FOR_TARGET"; then
11223   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11224 else
11225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11226 for as_dir in $PATH
11227 do
11228   IFS=$as_save_IFS
11229   test -z "$as_dir" && as_dir=.
11230   for ac_exec_ext in '' $ac_executable_extensions; do
11231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11232     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11234     break 2
11235   fi
11236 done
11237 done
11238
11239 fi
11240 fi
11241 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11242 if test -n "$WINDMC_FOR_TARGET"; then
11243   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11244 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11245 else
11246   echo "$as_me:$LINENO: result: no" >&5
11247 echo "${ECHO_T}no" >&6
11248 fi
11249
11250   done
11251 fi
11252
11253 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11254   for ncn_progname in windmc; do
11255     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11256 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11257     if test -x $with_build_time_tools/${ncn_progname}; then
11258       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11259       echo "$as_me:$LINENO: result: yes" >&5
11260 echo "${ECHO_T}yes" >&6
11261       break
11262     else
11263       echo "$as_me:$LINENO: result: no" >&5
11264 echo "${ECHO_T}no" >&6
11265     fi
11266   done
11267 fi
11268
11269 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11270   for ncn_progname in windmc; do
11271     if test -n "$ncn_target_tool_prefix"; then
11272       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11273 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11274 echo "$as_me:$LINENO: checking for $ac_word" >&5
11275 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11276 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11277   echo $ECHO_N "(cached) $ECHO_C" >&6
11278 else
11279   if test -n "$WINDMC_FOR_TARGET"; then
11280   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11281 else
11282 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11283 for as_dir in $PATH
11284 do
11285   IFS=$as_save_IFS
11286   test -z "$as_dir" && as_dir=.
11287   for ac_exec_ext in '' $ac_executable_extensions; do
11288   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11289     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11290     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11291     break 2
11292   fi
11293 done
11294 done
11295
11296 fi
11297 fi
11298 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11299 if test -n "$WINDMC_FOR_TARGET"; then
11300   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11301 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11302 else
11303   echo "$as_me:$LINENO: result: no" >&5
11304 echo "${ECHO_T}no" >&6
11305 fi
11306
11307     fi
11308     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11309       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11310 set dummy ${ncn_progname}; ac_word=$2
11311 echo "$as_me:$LINENO: checking for $ac_word" >&5
11312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11313 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11314   echo $ECHO_N "(cached) $ECHO_C" >&6
11315 else
11316   if test -n "$WINDMC_FOR_TARGET"; then
11317   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11318 else
11319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11320 for as_dir in $PATH
11321 do
11322   IFS=$as_save_IFS
11323   test -z "$as_dir" && as_dir=.
11324   for ac_exec_ext in '' $ac_executable_extensions; do
11325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11326     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11328     break 2
11329   fi
11330 done
11331 done
11332
11333 fi
11334 fi
11335 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11336 if test -n "$WINDMC_FOR_TARGET"; then
11337   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11338 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11339 else
11340   echo "$as_me:$LINENO: result: no" >&5
11341 echo "${ECHO_T}no" >&6
11342 fi
11343
11344     fi
11345     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11346   done
11347 fi
11348
11349 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11350   set dummy windmc
11351   if test $build = $target ; then
11352     WINDMC_FOR_TARGET="$2"
11353   else
11354     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11355   fi
11356 else
11357   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11358 fi
11359
11360 else
11361   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11362 fi
11363
11364
11365 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11366
11367 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11368 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11369 if test "x${build}" != "x${host}" ; then
11370   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11371     # We already found the complete path
11372     ac_dir=`dirname $AR_FOR_TARGET`
11373     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11374 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11375   else
11376     # Canadian cross, just use what we found
11377     echo "$as_me:$LINENO: result: pre-installed" >&5
11378 echo "${ECHO_T}pre-installed" >&6
11379   fi
11380 else
11381   ok=yes
11382   case " ${configdirs} " in
11383     *" binutils "*) ;;
11384     *) ok=no ;;
11385   esac
11386
11387   if test $ok = yes; then
11388     # An in-tree tool is available and we can use it
11389     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11390     echo "$as_me:$LINENO: result: just compiled" >&5
11391 echo "${ECHO_T}just compiled" >&6
11392   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11393     # We already found the complete path
11394     ac_dir=`dirname $AR_FOR_TARGET`
11395     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11396 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11397   elif test "x$target" = "x$host"; then
11398     # We can use an host tool
11399     AR_FOR_TARGET='$(AR)'
11400     echo "$as_me:$LINENO: result: host tool" >&5
11401 echo "${ECHO_T}host tool" >&6
11402   else
11403     # We need a cross tool
11404     echo "$as_me:$LINENO: result: pre-installed" >&5
11405 echo "${ECHO_T}pre-installed" >&6
11406   fi
11407 fi
11408
11409 echo "$as_me:$LINENO: checking where to find the target as" >&5
11410 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11411 if test "x${build}" != "x${host}" ; then
11412   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11413     # We already found the complete path
11414     ac_dir=`dirname $AS_FOR_TARGET`
11415     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11416 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11417   else
11418     # Canadian cross, just use what we found
11419     echo "$as_me:$LINENO: result: pre-installed" >&5
11420 echo "${ECHO_T}pre-installed" >&6
11421   fi
11422 else
11423   ok=yes
11424   case " ${configdirs} " in
11425     *" gas "*) ;;
11426     *) ok=no ;;
11427   esac
11428
11429   if test $ok = yes; then
11430     # An in-tree tool is available and we can use it
11431     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11432     echo "$as_me:$LINENO: result: just compiled" >&5
11433 echo "${ECHO_T}just compiled" >&6
11434   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11435     # We already found the complete path
11436     ac_dir=`dirname $AS_FOR_TARGET`
11437     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11438 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11439   elif test "x$target" = "x$host"; then
11440     # We can use an host tool
11441     AS_FOR_TARGET='$(AS)'
11442     echo "$as_me:$LINENO: result: host tool" >&5
11443 echo "${ECHO_T}host tool" >&6
11444   else
11445     # We need a cross tool
11446     echo "$as_me:$LINENO: result: pre-installed" >&5
11447 echo "${ECHO_T}pre-installed" >&6
11448   fi
11449 fi
11450
11451 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11452 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11453 if test "x${build}" != "x${host}" ; then
11454   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11455     # We already found the complete path
11456     ac_dir=`dirname $CC_FOR_TARGET`
11457     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11458 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11459   else
11460     # Canadian cross, just use what we found
11461     echo "$as_me:$LINENO: result: pre-installed" >&5
11462 echo "${ECHO_T}pre-installed" >&6
11463   fi
11464 else
11465   ok=yes
11466   case " ${configdirs} " in
11467     *" gcc "*) ;;
11468     *) ok=no ;;
11469   esac
11470
11471   if test $ok = yes; then
11472     # An in-tree tool is available and we can use it
11473     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11474     echo "$as_me:$LINENO: result: just compiled" >&5
11475 echo "${ECHO_T}just compiled" >&6
11476   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11477     # We already found the complete path
11478     ac_dir=`dirname $CC_FOR_TARGET`
11479     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11480 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11481   elif test "x$target" = "x$host"; then
11482     # We can use an host tool
11483     CC_FOR_TARGET='$(CC)'
11484     echo "$as_me:$LINENO: result: host tool" >&5
11485 echo "${ECHO_T}host tool" >&6
11486   else
11487     # We need a cross tool
11488     echo "$as_me:$LINENO: result: pre-installed" >&5
11489 echo "${ECHO_T}pre-installed" >&6
11490   fi
11491 fi
11492
11493 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11494 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11495 if test "x${build}" != "x${host}" ; then
11496   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11497     # We already found the complete path
11498     ac_dir=`dirname $CXX_FOR_TARGET`
11499     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11500 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11501   else
11502     # Canadian cross, just use what we found
11503     echo "$as_me:$LINENO: result: pre-installed" >&5
11504 echo "${ECHO_T}pre-installed" >&6
11505   fi
11506 else
11507   ok=yes
11508   case " ${configdirs} " in
11509     *" gcc "*) ;;
11510     *) ok=no ;;
11511   esac
11512   case ,${enable_languages}, in
11513     *,c++,*) ;;
11514     *) ok=no ;;
11515   esac
11516   if test $ok = yes; then
11517     # An in-tree tool is available and we can use it
11518     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'
11519     echo "$as_me:$LINENO: result: just compiled" >&5
11520 echo "${ECHO_T}just compiled" >&6
11521   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11522     # We already found the complete path
11523     ac_dir=`dirname $CXX_FOR_TARGET`
11524     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11525 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11526   elif test "x$target" = "x$host"; then
11527     # We can use an host tool
11528     CXX_FOR_TARGET='$(CXX)'
11529     echo "$as_me:$LINENO: result: host tool" >&5
11530 echo "${ECHO_T}host tool" >&6
11531   else
11532     # We need a cross tool
11533     echo "$as_me:$LINENO: result: pre-installed" >&5
11534 echo "${ECHO_T}pre-installed" >&6
11535   fi
11536 fi
11537
11538 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11539 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11540 if test "x${build}" != "x${host}" ; then
11541   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11542     # We already found the complete path
11543     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11544     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11545 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11546   else
11547     # Canadian cross, just use what we found
11548     echo "$as_me:$LINENO: result: pre-installed" >&5
11549 echo "${ECHO_T}pre-installed" >&6
11550   fi
11551 else
11552   ok=yes
11553   case " ${configdirs} " in
11554     *" gcc "*) ;;
11555     *) ok=no ;;
11556   esac
11557   case ,${enable_languages}, in
11558     *,c++,*) ;;
11559     *) ok=no ;;
11560   esac
11561   if test $ok = yes; then
11562     # An in-tree tool is available and we can use it
11563     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'
11564     echo "$as_me:$LINENO: result: just compiled" >&5
11565 echo "${ECHO_T}just compiled" >&6
11566   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11567     # We already found the complete path
11568     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11569     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11570 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11571   elif test "x$target" = "x$host"; then
11572     # We can use an host tool
11573     RAW_CXX_FOR_TARGET='$(CXX)'
11574     echo "$as_me:$LINENO: result: host tool" >&5
11575 echo "${ECHO_T}host tool" >&6
11576   else
11577     # We need a cross tool
11578     echo "$as_me:$LINENO: result: pre-installed" >&5
11579 echo "${ECHO_T}pre-installed" >&6
11580   fi
11581 fi
11582
11583 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11584 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11585 if test "x${build}" != "x${host}" ; then
11586   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11587     # We already found the complete path
11588     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11589     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11590 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11591   else
11592     # Canadian cross, just use what we found
11593     echo "$as_me:$LINENO: result: pre-installed" >&5
11594 echo "${ECHO_T}pre-installed" >&6
11595   fi
11596 else
11597   ok=yes
11598   case " ${configdirs} " in
11599     *" binutils "*) ;;
11600     *) ok=no ;;
11601   esac
11602
11603   if test $ok = yes; then
11604     # An in-tree tool is available and we can use it
11605     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11606     echo "$as_me:$LINENO: result: just compiled" >&5
11607 echo "${ECHO_T}just compiled" >&6
11608   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11609     # We already found the complete path
11610     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11611     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11612 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11613   elif test "x$target" = "x$host"; then
11614     # We can use an host tool
11615     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11616     echo "$as_me:$LINENO: result: host tool" >&5
11617 echo "${ECHO_T}host tool" >&6
11618   else
11619     # We need a cross tool
11620     echo "$as_me:$LINENO: result: pre-installed" >&5
11621 echo "${ECHO_T}pre-installed" >&6
11622   fi
11623 fi
11624
11625 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11626 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11627 if test "x${build}" != "x${host}" ; then
11628   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11629     # We already found the complete path
11630     ac_dir=`dirname $GCC_FOR_TARGET`
11631     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11632 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11633   else
11634     # Canadian cross, just use what we found
11635     echo "$as_me:$LINENO: result: pre-installed" >&5
11636 echo "${ECHO_T}pre-installed" >&6
11637   fi
11638 else
11639   ok=yes
11640   case " ${configdirs} " in
11641     *" gcc "*) ;;
11642     *) ok=no ;;
11643   esac
11644
11645   if test $ok = yes; then
11646     # An in-tree tool is available and we can use it
11647     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11648     echo "$as_me:$LINENO: result: just compiled" >&5
11649 echo "${ECHO_T}just compiled" >&6
11650   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11651     # We already found the complete path
11652     ac_dir=`dirname $GCC_FOR_TARGET`
11653     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11654 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11655   elif test "x$target" = "x$host"; then
11656     # We can use an host tool
11657     GCC_FOR_TARGET='$()'
11658     echo "$as_me:$LINENO: result: host tool" >&5
11659 echo "${ECHO_T}host tool" >&6
11660   else
11661     # We need a cross tool
11662     echo "$as_me:$LINENO: result: pre-installed" >&5
11663 echo "${ECHO_T}pre-installed" >&6
11664   fi
11665 fi
11666
11667 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11668 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11669 if test "x${build}" != "x${host}" ; then
11670   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11671     # We already found the complete path
11672     ac_dir=`dirname $GCJ_FOR_TARGET`
11673     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11674 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11675   else
11676     # Canadian cross, just use what we found
11677     echo "$as_me:$LINENO: result: pre-installed" >&5
11678 echo "${ECHO_T}pre-installed" >&6
11679   fi
11680 else
11681   ok=yes
11682   case " ${configdirs} " in
11683     *" gcc "*) ;;
11684     *) ok=no ;;
11685   esac
11686   case ,${enable_languages}, in
11687     *,java,*) ;;
11688     *) ok=no ;;
11689   esac
11690   if test $ok = yes; then
11691     # An in-tree tool is available and we can use it
11692     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11693     echo "$as_me:$LINENO: result: just compiled" >&5
11694 echo "${ECHO_T}just compiled" >&6
11695   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11696     # We already found the complete path
11697     ac_dir=`dirname $GCJ_FOR_TARGET`
11698     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11699 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11700   elif test "x$target" = "x$host"; then
11701     # We can use an host tool
11702     GCJ_FOR_TARGET='$(GCJ)'
11703     echo "$as_me:$LINENO: result: host tool" >&5
11704 echo "${ECHO_T}host tool" >&6
11705   else
11706     # We need a cross tool
11707     echo "$as_me:$LINENO: result: pre-installed" >&5
11708 echo "${ECHO_T}pre-installed" >&6
11709   fi
11710 fi
11711
11712 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11713 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11714 if test "x${build}" != "x${host}" ; then
11715   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11716     # We already found the complete path
11717     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11718     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11719 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11720   else
11721     # Canadian cross, just use what we found
11722     echo "$as_me:$LINENO: result: pre-installed" >&5
11723 echo "${ECHO_T}pre-installed" >&6
11724   fi
11725 else
11726   ok=yes
11727   case " ${configdirs} " in
11728     *" gcc "*) ;;
11729     *) ok=no ;;
11730   esac
11731   case ,${enable_languages}, in
11732     *,fortran,*) ;;
11733     *) ok=no ;;
11734   esac
11735   if test $ok = yes; then
11736     # An in-tree tool is available and we can use it
11737     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11738     echo "$as_me:$LINENO: result: just compiled" >&5
11739 echo "${ECHO_T}just compiled" >&6
11740   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11741     # We already found the complete path
11742     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11743     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11744 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11745   elif test "x$target" = "x$host"; then
11746     # We can use an host tool
11747     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11748     echo "$as_me:$LINENO: result: host tool" >&5
11749 echo "${ECHO_T}host tool" >&6
11750   else
11751     # We need a cross tool
11752     echo "$as_me:$LINENO: result: pre-installed" >&5
11753 echo "${ECHO_T}pre-installed" >&6
11754   fi
11755 fi
11756
11757 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11758 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11759 if test "x${build}" != "x${host}" ; then
11760   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11761     # We already found the complete path
11762     ac_dir=`dirname $LD_FOR_TARGET`
11763     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11764 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11765   else
11766     # Canadian cross, just use what we found
11767     echo "$as_me:$LINENO: result: pre-installed" >&5
11768 echo "${ECHO_T}pre-installed" >&6
11769   fi
11770 else
11771   ok=yes
11772   case " ${configdirs} " in
11773     *" ld "*) ;;
11774     *) ok=no ;;
11775   esac
11776
11777   if test $ok = yes; then
11778     # An in-tree tool is available and we can use it
11779     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11780     echo "$as_me:$LINENO: result: just compiled" >&5
11781 echo "${ECHO_T}just compiled" >&6
11782   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11783     # We already found the complete path
11784     ac_dir=`dirname $LD_FOR_TARGET`
11785     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11786 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11787   elif test "x$target" = "x$host"; then
11788     # We can use an host tool
11789     LD_FOR_TARGET='$(LD)'
11790     echo "$as_me:$LINENO: result: host tool" >&5
11791 echo "${ECHO_T}host tool" >&6
11792   else
11793     # We need a cross tool
11794     echo "$as_me:$LINENO: result: pre-installed" >&5
11795 echo "${ECHO_T}pre-installed" >&6
11796   fi
11797 fi
11798
11799 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11800 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11801 if test "x${build}" != "x${host}" ; then
11802   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11803     # We already found the complete path
11804     ac_dir=`dirname $LIPO_FOR_TARGET`
11805     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11806 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11807   else
11808     # Canadian cross, just use what we found
11809     echo "$as_me:$LINENO: result: pre-installed" >&5
11810 echo "${ECHO_T}pre-installed" >&6
11811   fi
11812 else
11813   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11814     # We already found the complete path
11815     ac_dir=`dirname $LIPO_FOR_TARGET`
11816     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11817 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11818   elif test "x$target" = "x$host"; then
11819     # We can use an host tool
11820     LIPO_FOR_TARGET='$(LIPO)'
11821     echo "$as_me:$LINENO: result: host tool" >&5
11822 echo "${ECHO_T}host tool" >&6
11823   else
11824     # We need a cross tool
11825     echo "$as_me:$LINENO: result: pre-installed" >&5
11826 echo "${ECHO_T}pre-installed" >&6
11827   fi
11828 fi
11829
11830 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11831 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11832 if test "x${build}" != "x${host}" ; then
11833   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11834     # We already found the complete path
11835     ac_dir=`dirname $NM_FOR_TARGET`
11836     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11837 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11838   else
11839     # Canadian cross, just use what we found
11840     echo "$as_me:$LINENO: result: pre-installed" >&5
11841 echo "${ECHO_T}pre-installed" >&6
11842   fi
11843 else
11844   ok=yes
11845   case " ${configdirs} " in
11846     *" binutils "*) ;;
11847     *) ok=no ;;
11848   esac
11849
11850   if test $ok = yes; then
11851     # An in-tree tool is available and we can use it
11852     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11853     echo "$as_me:$LINENO: result: just compiled" >&5
11854 echo "${ECHO_T}just compiled" >&6
11855   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11856     # We already found the complete path
11857     ac_dir=`dirname $NM_FOR_TARGET`
11858     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11859 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11860   elif test "x$target" = "x$host"; then
11861     # We can use an host tool
11862     NM_FOR_TARGET='$(NM)'
11863     echo "$as_me:$LINENO: result: host tool" >&5
11864 echo "${ECHO_T}host tool" >&6
11865   else
11866     # We need a cross tool
11867     echo "$as_me:$LINENO: result: pre-installed" >&5
11868 echo "${ECHO_T}pre-installed" >&6
11869   fi
11870 fi
11871
11872 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11873 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11874 if test "x${build}" != "x${host}" ; then
11875   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11876     # We already found the complete path
11877     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11878     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11879 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11880   else
11881     # Canadian cross, just use what we found
11882     echo "$as_me:$LINENO: result: pre-installed" >&5
11883 echo "${ECHO_T}pre-installed" >&6
11884   fi
11885 else
11886   ok=yes
11887   case " ${configdirs} " in
11888     *" binutils "*) ;;
11889     *) ok=no ;;
11890   esac
11891
11892   if test $ok = yes; then
11893     # An in-tree tool is available and we can use it
11894     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11895     echo "$as_me:$LINENO: result: just compiled" >&5
11896 echo "${ECHO_T}just compiled" >&6
11897   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11898     # We already found the complete path
11899     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11900     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11901 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11902   elif test "x$target" = "x$host"; then
11903     # We can use an host tool
11904     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11905     echo "$as_me:$LINENO: result: host tool" >&5
11906 echo "${ECHO_T}host tool" >&6
11907   else
11908     # We need a cross tool
11909     echo "$as_me:$LINENO: result: pre-installed" >&5
11910 echo "${ECHO_T}pre-installed" >&6
11911   fi
11912 fi
11913
11914 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11915 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11916 if test "x${build}" != "x${host}" ; then
11917   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11918     # We already found the complete path
11919     ac_dir=`dirname $RANLIB_FOR_TARGET`
11920     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11921 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11922   else
11923     # Canadian cross, just use what we found
11924     echo "$as_me:$LINENO: result: pre-installed" >&5
11925 echo "${ECHO_T}pre-installed" >&6
11926   fi
11927 else
11928   ok=yes
11929   case " ${configdirs} " in
11930     *" binutils "*) ;;
11931     *) ok=no ;;
11932   esac
11933
11934   if test $ok = yes; then
11935     # An in-tree tool is available and we can use it
11936     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11937     echo "$as_me:$LINENO: result: just compiled" >&5
11938 echo "${ECHO_T}just compiled" >&6
11939   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11940     # We already found the complete path
11941     ac_dir=`dirname $RANLIB_FOR_TARGET`
11942     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11943 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11944   elif test "x$target" = "x$host"; then
11945     # We can use an host tool
11946     RANLIB_FOR_TARGET='$(RANLIB)'
11947     echo "$as_me:$LINENO: result: host tool" >&5
11948 echo "${ECHO_T}host tool" >&6
11949   else
11950     # We need a cross tool
11951     echo "$as_me:$LINENO: result: pre-installed" >&5
11952 echo "${ECHO_T}pre-installed" >&6
11953   fi
11954 fi
11955
11956 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11957 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11958 if test "x${build}" != "x${host}" ; then
11959   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11960     # We already found the complete path
11961     ac_dir=`dirname $STRIP_FOR_TARGET`
11962     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11963 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11964   else
11965     # Canadian cross, just use what we found
11966     echo "$as_me:$LINENO: result: pre-installed" >&5
11967 echo "${ECHO_T}pre-installed" >&6
11968   fi
11969 else
11970   ok=yes
11971   case " ${configdirs} " in
11972     *" binutils "*) ;;
11973     *) ok=no ;;
11974   esac
11975
11976   if test $ok = yes; then
11977     # An in-tree tool is available and we can use it
11978     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11979     echo "$as_me:$LINENO: result: just compiled" >&5
11980 echo "${ECHO_T}just compiled" >&6
11981   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11982     # We already found the complete path
11983     ac_dir=`dirname $STRIP_FOR_TARGET`
11984     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11985 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11986   elif test "x$target" = "x$host"; then
11987     # We can use an host tool
11988     STRIP_FOR_TARGET='$(STRIP)'
11989     echo "$as_me:$LINENO: result: host tool" >&5
11990 echo "${ECHO_T}host tool" >&6
11991   else
11992     # We need a cross tool
11993     echo "$as_me:$LINENO: result: pre-installed" >&5
11994 echo "${ECHO_T}pre-installed" >&6
11995   fi
11996 fi
11997
11998 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11999 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12000 if test "x${build}" != "x${host}" ; then
12001   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12002     # We already found the complete path
12003     ac_dir=`dirname $WINDRES_FOR_TARGET`
12004     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12005 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12006   else
12007     # Canadian cross, just use what we found
12008     echo "$as_me:$LINENO: result: pre-installed" >&5
12009 echo "${ECHO_T}pre-installed" >&6
12010   fi
12011 else
12012   ok=yes
12013   case " ${configdirs} " in
12014     *" binutils "*) ;;
12015     *) ok=no ;;
12016   esac
12017
12018   if test $ok = yes; then
12019     # An in-tree tool is available and we can use it
12020     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12021     echo "$as_me:$LINENO: result: just compiled" >&5
12022 echo "${ECHO_T}just compiled" >&6
12023   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12024     # We already found the complete path
12025     ac_dir=`dirname $WINDRES_FOR_TARGET`
12026     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12027 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12028   elif test "x$target" = "x$host"; then
12029     # We can use an host tool
12030     WINDRES_FOR_TARGET='$(WINDRES)'
12031     echo "$as_me:$LINENO: result: host tool" >&5
12032 echo "${ECHO_T}host tool" >&6
12033   else
12034     # We need a cross tool
12035     echo "$as_me:$LINENO: result: pre-installed" >&5
12036 echo "${ECHO_T}pre-installed" >&6
12037   fi
12038 fi
12039
12040 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12041 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12042 if test "x${build}" != "x${host}" ; then
12043   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12044     # We already found the complete path
12045     ac_dir=`dirname $WINDMC_FOR_TARGET`
12046     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12047 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12048   else
12049     # Canadian cross, just use what we found
12050     echo "$as_me:$LINENO: result: pre-installed" >&5
12051 echo "${ECHO_T}pre-installed" >&6
12052   fi
12053 else
12054   ok=yes
12055   case " ${configdirs} " in
12056     *" binutils "*) ;;
12057     *) ok=no ;;
12058   esac
12059
12060   if test $ok = yes; then
12061     # An in-tree tool is available and we can use it
12062     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12063     echo "$as_me:$LINENO: result: just compiled" >&5
12064 echo "${ECHO_T}just compiled" >&6
12065   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12066     # We already found the complete path
12067     ac_dir=`dirname $WINDMC_FOR_TARGET`
12068     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12069 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12070   elif test "x$target" = "x$host"; then
12071     # We can use an host tool
12072     WINDMC_FOR_TARGET='$(WINDMC)'
12073     echo "$as_me:$LINENO: result: host tool" >&5
12074 echo "${ECHO_T}host tool" >&6
12075   else
12076     # We need a cross tool
12077     echo "$as_me:$LINENO: result: pre-installed" >&5
12078 echo "${ECHO_T}pre-installed" >&6
12079   fi
12080 fi
12081
12082
12083
12084
12085
12086 # Certain tools may need extra flags.
12087 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12088 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12089 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12090
12091 # When building target libraries, except in a Canadian cross, we use
12092 # the same toolchain as the compiler we just built.
12093 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12094 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12095 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12096 if test $host = $build; then
12097   case " $configdirs " in
12098     *" gcc "*)
12099       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12100       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12101       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12102       ;;
12103   esac
12104 fi
12105
12106
12107
12108
12109
12110 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12111 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12112 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12113 if test "${enable_maintainer_mode+set}" = set; then
12114   enableval="$enable_maintainer_mode"
12115   USE_MAINTAINER_MODE=$enableval
12116 else
12117   USE_MAINTAINER_MODE=no
12118 fi;
12119 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12120 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12121
12122
12123 if test "$USE_MAINTAINER_MODE" = yes; then
12124   MAINTAINER_MODE_TRUE=
12125   MAINTAINER_MODE_FALSE='#'
12126 else
12127   MAINTAINER_MODE_TRUE='#'
12128   MAINTAINER_MODE_FALSE=
12129 fi
12130 MAINT=$MAINTAINER_MODE_TRUE
12131
12132 # ---------------------
12133 # GCC bootstrap support
12134 # ---------------------
12135
12136 # Stage specific cflags for build.
12137 stage1_cflags="-g"
12138 case $build in
12139   vax-*-*)
12140     case ${GCC} in
12141       yes) stage1_cflags="-g -Wa,-J" ;;
12142       *) stage1_cflags="-g -J" ;;
12143     esac ;;
12144 esac
12145
12146 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12147 if test "$GCC" = yes; then
12148   saved_CFLAGS="$CFLAGS"
12149
12150   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12151   CFLAGS="$CFLAGS -fkeep-inline-functions"
12152   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12153 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12154   cat >conftest.$ac_ext <<_ACEOF
12155 /* confdefs.h.  */
12156 _ACEOF
12157 cat confdefs.h >>conftest.$ac_ext
12158 cat >>conftest.$ac_ext <<_ACEOF
12159 /* end confdefs.h.  */
12160
12161 #if (__GNUC__ < 3) \
12162     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12163                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12164 #error http://gcc.gnu.org/PR29382
12165 #endif
12166
12167 int
12168 main ()
12169 {
12170
12171   ;
12172   return 0;
12173 }
12174 _ACEOF
12175 rm -f conftest.$ac_objext
12176 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12177   (eval $ac_compile) 2>conftest.er1
12178   ac_status=$?
12179   grep -v '^ *+' conftest.er1 >conftest.err
12180   rm -f conftest.er1
12181   cat conftest.err >&5
12182   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12183   (exit $ac_status); } &&
12184          { ac_try='test -z "$ac_c_werror_flag"
12185                          || test ! -s conftest.err'
12186   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12187   (eval $ac_try) 2>&5
12188   ac_status=$?
12189   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12190   (exit $ac_status); }; } &&
12191          { ac_try='test -s conftest.$ac_objext'
12192   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12193   (eval $ac_try) 2>&5
12194   ac_status=$?
12195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12196   (exit $ac_status); }; }; then
12197   echo "$as_me:$LINENO: result: yes" >&5
12198 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12199 else
12200   echo "$as_me: failed program was:" >&5
12201 sed 's/^/| /' conftest.$ac_ext >&5
12202
12203 echo "$as_me:$LINENO: result: no" >&5
12204 echo "${ECHO_T}no" >&6
12205 fi
12206 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12207
12208   CFLAGS="$saved_CFLAGS"
12209 fi
12210
12211
12212
12213 # Enable --enable-checking in stage1 of the compiler.
12214 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12215 if test "${enable_stage1_checking+set}" = set; then
12216   enableval="$enable_stage1_checking"
12217   stage1_checking=--enable-checking=${enable_stage1_checking}
12218 else
12219   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12220   stage1_checking=--enable-checking=yes,types
12221 else
12222   stage1_checking=--enable-checking=$enable_checking,types
12223 fi
12224 fi;
12225
12226
12227 # Enable -Werror in bootstrap stage2 and later.
12228 # Check whether --enable-werror or --disable-werror was given.
12229 if test "${enable_werror+set}" = set; then
12230   enableval="$enable_werror"
12231
12232 else
12233   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12234   enable_werror=yes
12235 else
12236   enable_werror=no
12237 fi
12238 fi;
12239 case ${enable_werror} in
12240   yes) stage2_werror_flag="--enable-werror-always" ;;
12241   *) stage2_werror_flag="" ;;
12242 esac
12243
12244
12245 # Flags needed to enable html installing and building
12246
12247 # Check whether --with-datarootdir or --without-datarootdir was given.
12248 if test "${with_datarootdir+set}" = set; then
12249   withval="$with_datarootdir"
12250   datarootdir="\${prefix}/${withval}"
12251 else
12252   datarootdir="\${prefix}/share"
12253 fi;
12254
12255
12256 # Check whether --with-docdir or --without-docdir was given.
12257 if test "${with_docdir+set}" = set; then
12258   withval="$with_docdir"
12259   docdir="\${prefix}/${withval}"
12260 else
12261   docdir="\${datarootdir}/doc"
12262 fi;
12263
12264
12265 # Check whether --with-pdfdir or --without-pdfdir was given.
12266 if test "${with_pdfdir+set}" = set; then
12267   withval="$with_pdfdir"
12268   pdfdir="\${prefix}/${withval}"
12269 else
12270   pdfdir="\${docdir}"
12271 fi;
12272
12273
12274 # Check whether --with-htmldir or --without-htmldir was given.
12275 if test "${with_htmldir+set}" = set; then
12276   withval="$with_htmldir"
12277   htmldir="\${prefix}/${withval}"
12278 else
12279   htmldir="\${docdir}"
12280 fi;
12281
12282
12283
12284
12285
12286
12287           ac_config_files="$ac_config_files Makefile"
12288 cat >confcache <<\_ACEOF
12289 # This file is a shell script that caches the results of configure
12290 # tests run on this system so they can be shared between configure
12291 # scripts and configure runs, see configure's option --config-cache.
12292 # It is not useful on other systems.  If it contains results you don't
12293 # want to keep, you may remove or edit it.
12294 #
12295 # config.status only pays attention to the cache file if you give it
12296 # the --recheck option to rerun configure.
12297 #
12298 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12299 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12300 # following values.
12301
12302 _ACEOF
12303
12304 # The following way of writing the cache mishandles newlines in values,
12305 # but we know of no workaround that is simple, portable, and efficient.
12306 # So, don't put newlines in cache variables' values.
12307 # Ultrix sh set writes to stderr and can't be redirected directly,
12308 # and sets the high bit in the cache file unless we assign to the vars.
12309 {
12310   (set) 2>&1 |
12311     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12312     *ac_space=\ *)
12313       # `set' does not quote correctly, so add quotes (double-quote
12314       # substitution turns \\\\ into \\, and sed turns \\ into \).
12315       sed -n \
12316         "s/'/'\\\\''/g;
12317           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12318       ;;
12319     *)
12320       # `set' quotes correctly as required by POSIX, so do not add quotes.
12321       sed -n \
12322         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12323       ;;
12324     esac;
12325 } |
12326   sed '
12327      t clear
12328      : clear
12329      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12330      t end
12331      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12332      : end' >>confcache
12333 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12334   if test -w $cache_file; then
12335     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12336     cat confcache >$cache_file
12337   else
12338     echo "not updating unwritable cache $cache_file"
12339   fi
12340 fi
12341 rm -f confcache
12342
12343 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12344 # Let make expand exec_prefix.
12345 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12346
12347 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12348 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12349 # trailing colons and then remove the whole line if VPATH becomes empty
12350 # (actually we leave an empty line to preserve line numbers).
12351 if test "x$srcdir" = x.; then
12352   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12353 s/:*\$(srcdir):*/:/;
12354 s/:*\${srcdir}:*/:/;
12355 s/:*@srcdir@:*/:/;
12356 s/^\([^=]*=[     ]*\):*/\1/;
12357 s/:*$//;
12358 s/^[^=]*=[       ]*$//;
12359 }'
12360 fi
12361
12362 # Transform confdefs.h into DEFS.
12363 # Protect against shell expansion while executing Makefile rules.
12364 # Protect against Makefile macro expansion.
12365 #
12366 # If the first sed substitution is executed (which looks for macros that
12367 # take arguments), then we branch to the quote section.  Otherwise,
12368 # look for a macro that doesn't take arguments.
12369 cat >confdef2opt.sed <<\_ACEOF
12370 t clear
12371 : clear
12372 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12373 t quote
12374 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12375 t quote
12376 d
12377 : quote
12378 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12379 s,\[,\\&,g
12380 s,\],\\&,g
12381 s,\$,$$,g
12382 p
12383 _ACEOF
12384 # We use echo to avoid assuming a particular line-breaking character.
12385 # The extra dot is to prevent the shell from consuming trailing
12386 # line-breaks from the sub-command output.  A line-break within
12387 # single-quotes doesn't work because, if this script is created in a
12388 # platform that uses two characters for line-breaks (e.g., DOS), tr
12389 # would break.
12390 ac_LF_and_DOT=`echo; echo .`
12391 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12392 rm -f confdef2opt.sed
12393
12394
12395 ac_libobjs=
12396 ac_ltlibobjs=
12397 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12398   # 1. Remove the extension, and $U if already installed.
12399   ac_i=`echo "$ac_i" |
12400          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12401   # 2. Add them.
12402   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12403   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12404 done
12405 LIBOBJS=$ac_libobjs
12406
12407 LTLIBOBJS=$ac_ltlibobjs
12408
12409
12410
12411 : ${CONFIG_STATUS=./config.status}
12412 ac_clean_files_save=$ac_clean_files
12413 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12414 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12415 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12416 cat >$CONFIG_STATUS <<_ACEOF
12417 #! $SHELL
12418 # Generated by $as_me.
12419 # Run this file to recreate the current configuration.
12420 # Compiler output produced by configure, useful for debugging
12421 # configure, is in config.log if it exists.
12422
12423 debug=false
12424 ac_cs_recheck=false
12425 ac_cs_silent=false
12426 SHELL=\${CONFIG_SHELL-$SHELL}
12427 _ACEOF
12428
12429 cat >>$CONFIG_STATUS <<\_ACEOF
12430 ## --------------------- ##
12431 ## M4sh Initialization.  ##
12432 ## --------------------- ##
12433
12434 # Be Bourne compatible
12435 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12436   emulate sh
12437   NULLCMD=:
12438   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12439   # is contrary to our usage.  Disable this feature.
12440   alias -g '${1+"$@"}'='"$@"'
12441 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12442   set -o posix
12443 fi
12444 DUALCASE=1; export DUALCASE # for MKS sh
12445
12446 # Support unset when possible.
12447 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12448   as_unset=unset
12449 else
12450   as_unset=false
12451 fi
12452
12453
12454 # Work around bugs in pre-3.0 UWIN ksh.
12455 $as_unset ENV MAIL MAILPATH
12456 PS1='$ '
12457 PS2='> '
12458 PS4='+ '
12459
12460 # NLS nuisances.
12461 for as_var in \
12462   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12463   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12464   LC_TELEPHONE LC_TIME
12465 do
12466   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12467     eval $as_var=C; export $as_var
12468   else
12469     $as_unset $as_var
12470   fi
12471 done
12472
12473 # Required to use basename.
12474 if expr a : '\(a\)' >/dev/null 2>&1; then
12475   as_expr=expr
12476 else
12477   as_expr=false
12478 fi
12479
12480 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12481   as_basename=basename
12482 else
12483   as_basename=false
12484 fi
12485
12486
12487 # Name of the executable.
12488 as_me=`$as_basename "$0" ||
12489 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12490          X"$0" : 'X\(//\)$' \| \
12491          X"$0" : 'X\(/\)$' \| \
12492          .     : '\(.\)' 2>/dev/null ||
12493 echo X/"$0" |
12494     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12495           /^X\/\(\/\/\)$/{ s//\1/; q; }
12496           /^X\/\(\/\).*/{ s//\1/; q; }
12497           s/.*/./; q'`
12498
12499
12500 # PATH needs CR, and LINENO needs CR and PATH.
12501 # Avoid depending upon Character Ranges.
12502 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12503 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12504 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12505 as_cr_digits='0123456789'
12506 as_cr_alnum=$as_cr_Letters$as_cr_digits
12507
12508 # The user is always right.
12509 if test "${PATH_SEPARATOR+set}" != set; then
12510   echo "#! /bin/sh" >conf$$.sh
12511   echo  "exit 0"   >>conf$$.sh
12512   chmod +x conf$$.sh
12513   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12514     PATH_SEPARATOR=';'
12515   else
12516     PATH_SEPARATOR=:
12517   fi
12518   rm -f conf$$.sh
12519 fi
12520
12521
12522   as_lineno_1=$LINENO
12523   as_lineno_2=$LINENO
12524   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12525   test "x$as_lineno_1" != "x$as_lineno_2" &&
12526   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12527   # Find who we are.  Look in the path if we contain no path at all
12528   # relative or not.
12529   case $0 in
12530     *[\\/]* ) as_myself=$0 ;;
12531     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12532 for as_dir in $PATH
12533 do
12534   IFS=$as_save_IFS
12535   test -z "$as_dir" && as_dir=.
12536   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12537 done
12538
12539        ;;
12540   esac
12541   # We did not find ourselves, most probably we were run as `sh COMMAND'
12542   # in which case we are not to be found in the path.
12543   if test "x$as_myself" = x; then
12544     as_myself=$0
12545   fi
12546   if test ! -f "$as_myself"; then
12547     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12548 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12549    { (exit 1); exit 1; }; }
12550   fi
12551   case $CONFIG_SHELL in
12552   '')
12553     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12554 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12555 do
12556   IFS=$as_save_IFS
12557   test -z "$as_dir" && as_dir=.
12558   for as_base in sh bash ksh sh5; do
12559          case $as_dir in
12560          /*)
12561            if ("$as_dir/$as_base" -c '
12562   as_lineno_1=$LINENO
12563   as_lineno_2=$LINENO
12564   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12565   test "x$as_lineno_1" != "x$as_lineno_2" &&
12566   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12567              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12568              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12569              CONFIG_SHELL=$as_dir/$as_base
12570              export CONFIG_SHELL
12571              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12572            fi;;
12573          esac
12574        done
12575 done
12576 ;;
12577   esac
12578
12579   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12580   # uniformly replaced by the line number.  The first 'sed' inserts a
12581   # line-number line before each line; the second 'sed' does the real
12582   # work.  The second script uses 'N' to pair each line-number line
12583   # with the numbered line, and appends trailing '-' during
12584   # substitution so that $LINENO is not a special case at line end.
12585   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12586   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12587   sed '=' <$as_myself |
12588     sed '
12589       N
12590       s,$,-,
12591       : loop
12592       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12593       t loop
12594       s,-$,,
12595       s,^['$as_cr_digits']*\n,,
12596     ' >$as_me.lineno &&
12597   chmod +x $as_me.lineno ||
12598     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12599 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12600    { (exit 1); exit 1; }; }
12601
12602   # Don't try to exec as it changes $[0], causing all sort of problems
12603   # (the dirname of $[0] is not the place where we might find the
12604   # original and so on.  Autoconf is especially sensible to this).
12605   . ./$as_me.lineno
12606   # Exit status is that of the last command.
12607   exit
12608 }
12609
12610
12611 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12612   *c*,-n*) ECHO_N= ECHO_C='
12613 ' ECHO_T='      ' ;;
12614   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12615   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12616 esac
12617
12618 if expr a : '\(a\)' >/dev/null 2>&1; then
12619   as_expr=expr
12620 else
12621   as_expr=false
12622 fi
12623
12624 rm -f conf$$ conf$$.exe conf$$.file
12625 echo >conf$$.file
12626 if ln -s conf$$.file conf$$ 2>/dev/null; then
12627   # We could just check for DJGPP; but this test a) works b) is more generic
12628   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12629   if test -f conf$$.exe; then
12630     # Don't use ln at all; we don't have any links
12631     as_ln_s='cp -p'
12632   else
12633     as_ln_s='ln -s'
12634   fi
12635 elif ln conf$$.file conf$$ 2>/dev/null; then
12636   as_ln_s=ln
12637 else
12638   as_ln_s='cp -p'
12639 fi
12640 rm -f conf$$ conf$$.exe conf$$.file
12641
12642 if mkdir -p . 2>/dev/null; then
12643   as_mkdir_p=:
12644 else
12645   test -d ./-p && rmdir ./-p
12646   as_mkdir_p=false
12647 fi
12648
12649 as_executable_p="test -f"
12650
12651 # Sed expression to map a string onto a valid CPP name.
12652 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12653
12654 # Sed expression to map a string onto a valid variable name.
12655 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12656
12657
12658 # IFS
12659 # We need space, tab and new line, in precisely that order.
12660 as_nl='
12661 '
12662 IFS="   $as_nl"
12663
12664 # CDPATH.
12665 $as_unset CDPATH
12666
12667 exec 6>&1
12668
12669 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12670 # report actual input values of CONFIG_FILES etc. instead of their
12671 # values after options handling.  Logging --version etc. is OK.
12672 exec 5>>config.log
12673 {
12674   echo
12675   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12676 ## Running $as_me. ##
12677 _ASBOX
12678 } >&5
12679 cat >&5 <<_CSEOF
12680
12681 This file was extended by $as_me, which was
12682 generated by GNU Autoconf 2.59.  Invocation command line was
12683
12684   CONFIG_FILES    = $CONFIG_FILES
12685   CONFIG_HEADERS  = $CONFIG_HEADERS
12686   CONFIG_LINKS    = $CONFIG_LINKS
12687   CONFIG_COMMANDS = $CONFIG_COMMANDS
12688   $ $0 $@
12689
12690 _CSEOF
12691 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12692 echo >&5
12693 _ACEOF
12694
12695 # Files that config.status was made for.
12696 if test -n "$ac_config_files"; then
12697   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12698 fi
12699
12700 if test -n "$ac_config_headers"; then
12701   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12702 fi
12703
12704 if test -n "$ac_config_links"; then
12705   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12706 fi
12707
12708 if test -n "$ac_config_commands"; then
12709   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12710 fi
12711
12712 cat >>$CONFIG_STATUS <<\_ACEOF
12713
12714 ac_cs_usage="\
12715 \`$as_me' instantiates files from templates according to the
12716 current configuration.
12717
12718 Usage: $0 [OPTIONS] [FILE]...
12719
12720   -h, --help       print this help, then exit
12721   -V, --version    print version number, then exit
12722   -q, --quiet      do not print progress messages
12723   -d, --debug      don't remove temporary files
12724       --recheck    update $as_me by reconfiguring in the same conditions
12725   --file=FILE[:TEMPLATE]
12726                    instantiate the configuration file FILE
12727
12728 Configuration files:
12729 $config_files
12730
12731 Report bugs to <bug-autoconf@gnu.org>."
12732 _ACEOF
12733
12734 cat >>$CONFIG_STATUS <<_ACEOF
12735 ac_cs_version="\\
12736 config.status
12737 configured by $0, generated by GNU Autoconf 2.59,
12738   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12739
12740 Copyright (C) 2003 Free Software Foundation, Inc.
12741 This config.status script is free software; the Free Software Foundation
12742 gives unlimited permission to copy, distribute and modify it."
12743 srcdir=$srcdir
12744 INSTALL="$INSTALL"
12745 _ACEOF
12746
12747 cat >>$CONFIG_STATUS <<\_ACEOF
12748 # If no file are specified by the user, then we need to provide default
12749 # value.  By we need to know if files were specified by the user.
12750 ac_need_defaults=:
12751 while test $# != 0
12752 do
12753   case $1 in
12754   --*=*)
12755     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12756     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12757     ac_shift=:
12758     ;;
12759   -*)
12760     ac_option=$1
12761     ac_optarg=$2
12762     ac_shift=shift
12763     ;;
12764   *) # This is not an option, so the user has probably given explicit
12765      # arguments.
12766      ac_option=$1
12767      ac_need_defaults=false;;
12768   esac
12769
12770   case $ac_option in
12771   # Handling of the options.
12772 _ACEOF
12773 cat >>$CONFIG_STATUS <<\_ACEOF
12774   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12775     ac_cs_recheck=: ;;
12776   --version | --vers* | -V )
12777     echo "$ac_cs_version"; exit 0 ;;
12778   --he | --h)
12779     # Conflict between --help and --header
12780     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12781 Try \`$0 --help' for more information." >&5
12782 echo "$as_me: error: ambiguous option: $1
12783 Try \`$0 --help' for more information." >&2;}
12784    { (exit 1); exit 1; }; };;
12785   --help | --hel | -h )
12786     echo "$ac_cs_usage"; exit 0 ;;
12787   --debug | --d* | -d )
12788     debug=: ;;
12789   --file | --fil | --fi | --f )
12790     $ac_shift
12791     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12792     ac_need_defaults=false;;
12793   --header | --heade | --head | --hea )
12794     $ac_shift
12795     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12796     ac_need_defaults=false;;
12797   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12798   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12799     ac_cs_silent=: ;;
12800
12801   # This is an error.
12802   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12803 Try \`$0 --help' for more information." >&5
12804 echo "$as_me: error: unrecognized option: $1
12805 Try \`$0 --help' for more information." >&2;}
12806    { (exit 1); exit 1; }; } ;;
12807
12808   *) ac_config_targets="$ac_config_targets $1" ;;
12809
12810   esac
12811   shift
12812 done
12813
12814 ac_configure_extra_args=
12815
12816 if $ac_cs_silent; then
12817   exec 6>/dev/null
12818   ac_configure_extra_args="$ac_configure_extra_args --silent"
12819 fi
12820
12821 _ACEOF
12822 cat >>$CONFIG_STATUS <<_ACEOF
12823 if \$ac_cs_recheck; then
12824   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12825   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12826 fi
12827
12828 _ACEOF
12829
12830
12831
12832
12833
12834 cat >>$CONFIG_STATUS <<\_ACEOF
12835 for ac_config_target in $ac_config_targets
12836 do
12837   case "$ac_config_target" in
12838   # Handling of arguments.
12839   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12840   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12841 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12842    { (exit 1); exit 1; }; };;
12843   esac
12844 done
12845
12846 # If the user did not use the arguments to specify the items to instantiate,
12847 # then the envvar interface is used.  Set only those that are not.
12848 # We use the long form for the default assignment because of an extremely
12849 # bizarre bug on SunOS 4.1.3.
12850 if $ac_need_defaults; then
12851   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12852 fi
12853
12854 # Have a temporary directory for convenience.  Make it in the build tree
12855 # simply because there is no reason to put it here, and in addition,
12856 # creating and moving files from /tmp can sometimes cause problems.
12857 # Create a temporary directory, and hook for its removal unless debugging.
12858 $debug ||
12859 {
12860   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12861   trap '{ (exit 1); exit 1; }' 1 2 13 15
12862 }
12863
12864 # Create a (secure) tmp directory for tmp files.
12865
12866 {
12867   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12868   test -n "$tmp" && test -d "$tmp"
12869 }  ||
12870 {
12871   tmp=./confstat$$-$RANDOM
12872   (umask 077 && mkdir $tmp)
12873 } ||
12874 {
12875    echo "$me: cannot create a temporary directory in ." >&2
12876    { (exit 1); exit 1; }
12877 }
12878
12879 _ACEOF
12880
12881 cat >>$CONFIG_STATUS <<_ACEOF
12882
12883 #
12884 # CONFIG_FILES section.
12885 #
12886
12887 # No need to generate the scripts if there are no CONFIG_FILES.
12888 # This happens for instance when ./config.status config.h
12889 if test -n "\$CONFIG_FILES"; then
12890   # Protect against being on the right side of a sed subst in config.status.
12891   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12892    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12893 s,@SHELL@,$SHELL,;t t
12894 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12895 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12896 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12897 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12898 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12899 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12900 s,@exec_prefix@,$exec_prefix,;t t
12901 s,@prefix@,$prefix,;t t
12902 s,@program_transform_name@,$program_transform_name,;t t
12903 s,@bindir@,$bindir,;t t
12904 s,@sbindir@,$sbindir,;t t
12905 s,@libexecdir@,$libexecdir,;t t
12906 s,@datadir@,$datadir,;t t
12907 s,@sysconfdir@,$sysconfdir,;t t
12908 s,@sharedstatedir@,$sharedstatedir,;t t
12909 s,@localstatedir@,$localstatedir,;t t
12910 s,@libdir@,$libdir,;t t
12911 s,@includedir@,$includedir,;t t
12912 s,@oldincludedir@,$oldincludedir,;t t
12913 s,@infodir@,$infodir,;t t
12914 s,@mandir@,$mandir,;t t
12915 s,@build_alias@,$build_alias,;t t
12916 s,@host_alias@,$host_alias,;t t
12917 s,@target_alias@,$target_alias,;t t
12918 s,@DEFS@,$DEFS,;t t
12919 s,@ECHO_C@,$ECHO_C,;t t
12920 s,@ECHO_N@,$ECHO_N,;t t
12921 s,@ECHO_T@,$ECHO_T,;t t
12922 s,@LIBS@,$LIBS,;t t
12923 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12924 s,@build@,$build,;t t
12925 s,@build_cpu@,$build_cpu,;t t
12926 s,@build_vendor@,$build_vendor,;t t
12927 s,@build_os@,$build_os,;t t
12928 s,@build_noncanonical@,$build_noncanonical,;t t
12929 s,@host_noncanonical@,$host_noncanonical,;t t
12930 s,@target_noncanonical@,$target_noncanonical,;t t
12931 s,@host@,$host,;t t
12932 s,@host_cpu@,$host_cpu,;t t
12933 s,@host_vendor@,$host_vendor,;t t
12934 s,@host_os@,$host_os,;t t
12935 s,@target@,$target,;t t
12936 s,@target_cpu@,$target_cpu,;t t
12937 s,@target_vendor@,$target_vendor,;t t
12938 s,@target_os@,$target_os,;t t
12939 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12940 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12941 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12942 s,@LN@,$LN,;t t
12943 s,@LN_S@,$LN_S,;t t
12944 s,@build_libsubdir@,$build_libsubdir,;t t
12945 s,@build_subdir@,$build_subdir,;t t
12946 s,@host_subdir@,$host_subdir,;t t
12947 s,@target_subdir@,$target_subdir,;t t
12948 s,@CC@,$CC,;t t
12949 s,@CFLAGS@,$CFLAGS,;t t
12950 s,@LDFLAGS@,$LDFLAGS,;t t
12951 s,@CPPFLAGS@,$CPPFLAGS,;t t
12952 s,@ac_ct_CC@,$ac_ct_CC,;t t
12953 s,@EXEEXT@,$EXEEXT,;t t
12954 s,@OBJEXT@,$OBJEXT,;t t
12955 s,@CXX@,$CXX,;t t
12956 s,@CXXFLAGS@,$CXXFLAGS,;t t
12957 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12958 s,@GNATBIND@,$GNATBIND,;t t
12959 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12960 s,@GNATMAKE@,$GNATMAKE,;t t
12961 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12962 s,@do_compare@,$do_compare,;t t
12963 s,@gmplibs@,$gmplibs,;t t
12964 s,@gmpinc@,$gmpinc,;t t
12965 s,@stage1_languages@,$stage1_languages,;t t
12966 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12967 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12968 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12969 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12970 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12971 s,@tooldir@,$tooldir,;t t
12972 s,@build_tooldir@,$build_tooldir,;t t
12973 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12974 s,@GDB_TK@,$GDB_TK,;t t
12975 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12976 s,@build_configargs@,$build_configargs,;t t
12977 s,@build_configdirs@,$build_configdirs,;t t
12978 s,@host_configargs@,$host_configargs,;t t
12979 s,@configdirs@,$configdirs,;t t
12980 s,@target_configargs@,$target_configargs,;t t
12981 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12982 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12983 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12984 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12985 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12986 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12987 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12988 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12989 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12990 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12991 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12992 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12993 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12994 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12995 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12996 s,@config_shell@,$config_shell,;t t
12997 s,@YACC@,$YACC,;t t
12998 s,@BISON@,$BISON,;t t
12999 s,@M4@,$M4,;t t
13000 s,@LEX@,$LEX,;t t
13001 s,@FLEX@,$FLEX,;t t
13002 s,@MAKEINFO@,$MAKEINFO,;t t
13003 s,@EXPECT@,$EXPECT,;t t
13004 s,@RUNTEST@,$RUNTEST,;t t
13005 s,@AR@,$AR,;t t
13006 s,@AS@,$AS,;t t
13007 s,@DLLTOOL@,$DLLTOOL,;t t
13008 s,@LD@,$LD,;t t
13009 s,@LIPO@,$LIPO,;t t
13010 s,@NM@,$NM,;t t
13011 s,@RANLIB@,$RANLIB,;t t
13012 s,@STRIP@,$STRIP,;t t
13013 s,@WINDRES@,$WINDRES,;t t
13014 s,@WINDMC@,$WINDMC,;t t
13015 s,@OBJCOPY@,$OBJCOPY,;t t
13016 s,@OBJDUMP@,$OBJDUMP,;t t
13017 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13018 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13019 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13020 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13021 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13022 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13023 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13024 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13025 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13026 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13027 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13028 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13029 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13030 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13031 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13032 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13033 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13034 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13035 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13036 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13037 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13038 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13039 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13040 s,@MAINT@,$MAINT,;t t
13041 s,@stage1_cflags@,$stage1_cflags,;t t
13042 s,@stage1_checking@,$stage1_checking,;t t
13043 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13044 s,@datarootdir@,$datarootdir,;t t
13045 s,@docdir@,$docdir,;t t
13046 s,@pdfdir@,$pdfdir,;t t
13047 s,@htmldir@,$htmldir,;t t
13048 s,@LIBOBJS@,$LIBOBJS,;t t
13049 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13050 /@serialization_dependencies@/r $serialization_dependencies
13051 s,@serialization_dependencies@,,;t t
13052 /@host_makefile_frag@/r $host_makefile_frag
13053 s,@host_makefile_frag@,,;t t
13054 /@target_makefile_frag@/r $target_makefile_frag
13055 s,@target_makefile_frag@,,;t t
13056 /@alphaieee_frag@/r $alphaieee_frag
13057 s,@alphaieee_frag@,,;t t
13058 /@ospace_frag@/r $ospace_frag
13059 s,@ospace_frag@,,;t t
13060 CEOF
13061
13062 _ACEOF
13063
13064   cat >>$CONFIG_STATUS <<\_ACEOF
13065   # Split the substitutions into bite-sized pieces for seds with
13066   # small command number limits, like on Digital OSF/1 and HP-UX.
13067   ac_max_sed_lines=48
13068   ac_sed_frag=1 # Number of current file.
13069   ac_beg=1 # First line for current file.
13070   ac_end=$ac_max_sed_lines # Line after last line for current file.
13071   ac_more_lines=:
13072   ac_sed_cmds=
13073   while $ac_more_lines; do
13074     if test $ac_beg -gt 1; then
13075       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13076     else
13077       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13078     fi
13079     if test ! -s $tmp/subs.frag; then
13080       ac_more_lines=false
13081     else
13082       # The purpose of the label and of the branching condition is to
13083       # speed up the sed processing (if there are no `@' at all, there
13084       # is no need to browse any of the substitutions).
13085       # These are the two extra sed commands mentioned above.
13086       (echo ':t
13087   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13088       if test -z "$ac_sed_cmds"; then
13089         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13090       else
13091         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13092       fi
13093       ac_sed_frag=`expr $ac_sed_frag + 1`
13094       ac_beg=$ac_end
13095       ac_end=`expr $ac_end + $ac_max_sed_lines`
13096     fi
13097   done
13098   if test -z "$ac_sed_cmds"; then
13099     ac_sed_cmds=cat
13100   fi
13101 fi # test -n "$CONFIG_FILES"
13102
13103 _ACEOF
13104 cat >>$CONFIG_STATUS <<\_ACEOF
13105 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13106   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13107   case $ac_file in
13108   - | *:- | *:-:* ) # input from stdin
13109         cat >$tmp/stdin
13110         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13111         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13112   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13113         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13114   * )   ac_file_in=$ac_file.in ;;
13115   esac
13116
13117   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13118   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13119 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13120          X"$ac_file" : 'X\(//\)[^/]' \| \
13121          X"$ac_file" : 'X\(//\)$' \| \
13122          X"$ac_file" : 'X\(/\)' \| \
13123          .     : '\(.\)' 2>/dev/null ||
13124 echo X"$ac_file" |
13125     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13126           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13127           /^X\(\/\/\)$/{ s//\1/; q; }
13128           /^X\(\/\).*/{ s//\1/; q; }
13129           s/.*/./; q'`
13130   { if $as_mkdir_p; then
13131     mkdir -p "$ac_dir"
13132   else
13133     as_dir="$ac_dir"
13134     as_dirs=
13135     while test ! -d "$as_dir"; do
13136       as_dirs="$as_dir $as_dirs"
13137       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13138 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13139          X"$as_dir" : 'X\(//\)[^/]' \| \
13140          X"$as_dir" : 'X\(//\)$' \| \
13141          X"$as_dir" : 'X\(/\)' \| \
13142          .     : '\(.\)' 2>/dev/null ||
13143 echo X"$as_dir" |
13144     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13145           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13146           /^X\(\/\/\)$/{ s//\1/; q; }
13147           /^X\(\/\).*/{ s//\1/; q; }
13148           s/.*/./; q'`
13149     done
13150     test ! -n "$as_dirs" || mkdir $as_dirs
13151   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13152 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13153    { (exit 1); exit 1; }; }; }
13154
13155   ac_builddir=.
13156
13157 if test "$ac_dir" != .; then
13158   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13159   # A "../" for each directory in $ac_dir_suffix.
13160   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13161 else
13162   ac_dir_suffix= ac_top_builddir=
13163 fi
13164
13165 case $srcdir in
13166   .)  # No --srcdir option.  We are building in place.
13167     ac_srcdir=.
13168     if test -z "$ac_top_builddir"; then
13169        ac_top_srcdir=.
13170     else
13171        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13172     fi ;;
13173   [\\/]* | ?:[\\/]* )  # Absolute path.
13174     ac_srcdir=$srcdir$ac_dir_suffix;
13175     ac_top_srcdir=$srcdir ;;
13176   *) # Relative path.
13177     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13178     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13179 esac
13180
13181 # Do not use `cd foo && pwd` to compute absolute paths, because
13182 # the directories may not exist.
13183 case `pwd` in
13184 .) ac_abs_builddir="$ac_dir";;
13185 *)
13186   case "$ac_dir" in
13187   .) ac_abs_builddir=`pwd`;;
13188   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13189   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13190   esac;;
13191 esac
13192 case $ac_abs_builddir in
13193 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13194 *)
13195   case ${ac_top_builddir}. in
13196   .) ac_abs_top_builddir=$ac_abs_builddir;;
13197   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13198   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13199   esac;;
13200 esac
13201 case $ac_abs_builddir in
13202 .) ac_abs_srcdir=$ac_srcdir;;
13203 *)
13204   case $ac_srcdir in
13205   .) ac_abs_srcdir=$ac_abs_builddir;;
13206   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13207   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13208   esac;;
13209 esac
13210 case $ac_abs_builddir in
13211 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13212 *)
13213   case $ac_top_srcdir in
13214   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13215   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13216   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13217   esac;;
13218 esac
13219
13220
13221   case $INSTALL in
13222   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13223   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13224   esac
13225
13226   if test x"$ac_file" != x-; then
13227     { echo "$as_me:$LINENO: creating $ac_file" >&5
13228 echo "$as_me: creating $ac_file" >&6;}
13229     rm -f "$ac_file"
13230   fi
13231   # Let's still pretend it is `configure' which instantiates (i.e., don't
13232   # use $as_me), people would be surprised to read:
13233   #    /* config.h.  Generated by config.status.  */
13234   if test x"$ac_file" = x-; then
13235     configure_input=
13236   else
13237     configure_input="$ac_file.  "
13238   fi
13239   configure_input=$configure_input"Generated from `echo $ac_file_in |
13240                                      sed 's,.*/,,'` by configure."
13241
13242   # First look for the input files in the build tree, otherwise in the
13243   # src tree.
13244   ac_file_inputs=`IFS=:
13245     for f in $ac_file_in; do
13246       case $f in
13247       -) echo $tmp/stdin ;;
13248       [\\/$]*)
13249          # Absolute (can't be DOS-style, as IFS=:)
13250          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13251 echo "$as_me: error: cannot find input file: $f" >&2;}
13252    { (exit 1); exit 1; }; }
13253          echo "$f";;
13254       *) # Relative
13255          if test -f "$f"; then
13256            # Build tree
13257            echo "$f"
13258          elif test -f "$srcdir/$f"; then
13259            # Source tree
13260            echo "$srcdir/$f"
13261          else
13262            # /dev/null tree
13263            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13264 echo "$as_me: error: cannot find input file: $f" >&2;}
13265    { (exit 1); exit 1; }; }
13266          fi;;
13267       esac
13268     done` || { (exit 1); exit 1; }
13269 _ACEOF
13270 cat >>$CONFIG_STATUS <<_ACEOF
13271   sed "$ac_vpsub
13272 $extrasub
13273 _ACEOF
13274 cat >>$CONFIG_STATUS <<\_ACEOF
13275 :t
13276 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13277 s,@configure_input@,$configure_input,;t t
13278 s,@srcdir@,$ac_srcdir,;t t
13279 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13280 s,@top_srcdir@,$ac_top_srcdir,;t t
13281 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13282 s,@builddir@,$ac_builddir,;t t
13283 s,@abs_builddir@,$ac_abs_builddir,;t t
13284 s,@top_builddir@,$ac_top_builddir,;t t
13285 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13286 s,@INSTALL@,$ac_INSTALL,;t t
13287 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13288   rm -f $tmp/stdin
13289   if test x"$ac_file" != x-; then
13290     mv $tmp/out $ac_file
13291   else
13292     cat $tmp/out
13293     rm -f $tmp/out
13294   fi
13295
13296 done
13297 _ACEOF
13298
13299 cat >>$CONFIG_STATUS <<\_ACEOF
13300
13301 { (exit 0); exit 0; }
13302 _ACEOF
13303 chmod +x $CONFIG_STATUS
13304 ac_clean_files=$ac_clean_files_save
13305
13306
13307 # configure is writing to config.log, and then calls config.status.
13308 # config.status does its own redirection, appending to config.log.
13309 # Unfortunately, on DOS this fails, as config.log is still kept open
13310 # by configure, so config.status won't be able to write to it; its
13311 # output is simply discarded.  So we exec the FD to /dev/null,
13312 # effectively closing config.log, so it can be properly (re)opened and
13313 # appended to by config.status.  When coming back to configure, we
13314 # need to make the FD available again.
13315 if test "$no_create" != yes; then
13316   ac_cs_success=:
13317   ac_config_status_args=
13318   test "$silent" = yes &&
13319     ac_config_status_args="$ac_config_status_args --quiet"
13320   exec 5>/dev/null
13321   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13322   exec 5>>config.log
13323   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13324   # would make configure fail if this is the last instruction.
13325   $ac_cs_success || { (exit 1); exit 1; }
13326 fi
13327