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 GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --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 ld gas 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     ;;
2647   v810-*-*)
2648     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2649     ;;
2650   v850-*-*)
2651     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2652     ;;
2653   v850e-*-*)
2654     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2655     ;;
2656   v850ea-*-*)
2657     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2658     ;;
2659   vax-*-vms)
2660     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2661     ;;
2662   vax-*-*)
2663     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2664     ;;
2665   xtensa*-*-*)
2666     noconfigdirs="$noconfigdirs ${libgcj}"
2667     ;;
2668   ip2k-*-*)
2669     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2670     ;;
2671   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2672     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2673     ;;
2674   *-*-lynxos*)
2675     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2676     ;;
2677   *-*-*)
2678     noconfigdirs="$noconfigdirs ${libgcj}"
2679     ;;
2680 esac
2681
2682 # If we aren't building newlib, then don't build libgloss, since libgloss
2683 # depends upon some newlib header files.
2684 case "${noconfigdirs}" in
2685   *target-libgloss*) ;;
2686   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2687 esac
2688
2689 # Work in distributions that contain no compiler tools, like Autoconf.
2690 tentative_cc=""
2691 host_makefile_frag=/dev/null
2692 if test -d ${srcdir}/config ; then
2693 case "${host}" in
2694   m68k-hp-hpux*)
2695     # Avoid "too much defining" errors from HPUX compiler.
2696     tentative_cc="cc -Wp,-H256000"
2697     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2698     # If it's HP/UX ar, this should be harmless.
2699     RANLIB="ar ts"
2700     ;;
2701   m68k-apollo-sysv*)
2702     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2703     ;;
2704   m68k-apollo-bsd*)
2705     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2706     # chokes on bfd, the compiler won't let you assign integers to enums, and
2707     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2708     # the apollo compiler" (the preferred version of GCC could be called cc,
2709     # or whatever), but I'm not sure leaving CC as cc is any better...
2710     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2711     # Used to have BISON=yacc.
2712     tentative_cc=gcc
2713     ;;
2714   m88k-dg-dgux*)
2715     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2716     ;;
2717   m88k-harris-cxux*)
2718     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2719     tentative_cc="cc -Xa"
2720     host_makefile_frag="config/mh-cxux"
2721     ;;
2722   m88k-motorola-sysv*)
2723     ;;
2724   mips*-dec-ultrix*)
2725     tentative_cc="cc -Wf,-XNg1000"
2726     host_makefile_frag="config/mh-decstation"
2727     ;;
2728   mips*-nec-sysv4*)
2729     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2730     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2731     host_makefile_frag="config/mh-necv4"
2732     ;;
2733   mips*-sgi-irix4*)
2734     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2735     # environment.  Also bump switch table size so that cp-parse will
2736     # compile.  Bump string length limit so linker builds.
2737     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2738     ;;
2739   mips*-*-sysv4*)
2740     host_makefile_frag="config/mh-sysv4"
2741     ;;
2742   mips*-*-sysv*)
2743     # This is for a MIPS running RISC/os 4.52C.
2744
2745     # This is needed for GDB, but needs to be in the top-level make because
2746     # if a library is compiled with the bsd headers and gets linked with the
2747     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2748     # a different size).
2749     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2750     # known except to select the sysv environment.  Could we use /proc instead?
2751     # These "sysv environments" and "bsd environments" often end up being a pain.
2752     #
2753     # This is not part of CFLAGS because perhaps not all C compilers have this
2754     # option.
2755     tentative_cc="cc -systype sysv"
2756     ;;
2757   i370-ibm-opened*)
2758     tentative_cc="c89"
2759     ;;
2760   i[3456789]86-*-sysv5*)
2761     host_makefile_frag="config/mh-sysv5"
2762     ;;
2763   i[3456789]86-*-dgux*)
2764     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2765     host_makefile_frag="config/mh-dgux386"
2766     ;;
2767   i[3456789]86-ncr-sysv4.3*)
2768     # The MetaWare compiler will generate a copyright message unless you
2769     # turn it off by adding the -Hnocopyr flag.
2770     tentative_cc="cc -Hnocopyr"
2771     ;;
2772   i[3456789]86-ncr-sysv4*)
2773     # for an NCR 3000 (i486/SVR4) system.
2774     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2775     # This compiler not only emits obnoxious copyright messages every time
2776     # you run it, but it chokes and dies on a whole bunch of GNU source
2777     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2778     tentative_cc="/usr/ccs/ATT/cc"
2779     host_makefile_frag="config/mh-ncr3000"
2780     ;;
2781   i[3456789]86-*-sco3.2v5*)
2782     ;;
2783   i[3456789]86-*-sco*)
2784     # The native C compiler botches some simple uses of const.  Unfortunately,
2785     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2786     tentative_cc="cc -Dconst="
2787     host_makefile_frag="config/mh-sco"
2788     ;;
2789   i[3456789]86-*-udk*)
2790     host_makefile_frag="config/mh-sysv5"
2791     ;;
2792   i[3456789]86-*-solaris2*)
2793     host_makefile_frag="config/mh-sysv4"
2794     ;;
2795   i[3456789]86-*-msdosdjgpp*)
2796     host_makefile_frag="config/mh-djgpp"
2797     ;;
2798   *-cygwin*)
2799
2800 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2801 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2802 echo a >cygwin-cat-check
2803 if test `cat cygwin-cat-check` == a ; then
2804   rm cygwin-cat-check
2805   echo "$as_me:$LINENO: result: yes" >&5
2806 echo "${ECHO_T}yes" >&6
2807 else
2808   rm cygwin-cat-check
2809   echo "$as_me:$LINENO: result: no" >&5
2810 echo "${ECHO_T}no" >&6
2811   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2812   Please either mount the build directory in binary mode or run the following
2813   commands before running any configure script:
2814 set -o igncr
2815 export SHELLOPTS
2816   " >&5
2817 echo "$as_me: error: The cat command does not ignore carriage return characters.
2818   Please either mount the build directory in binary mode or run the following
2819   commands before running any configure script:
2820 set -o igncr
2821 export SHELLOPTS
2822   " >&2;}
2823    { (exit 1); exit 1; }; }
2824 fi
2825
2826     host_makefile_frag="config/mh-cygwin"
2827     ;;
2828   *-mingw*)
2829     host_makefile_frag="config/mh-mingw"
2830     ;;
2831   *-interix*)
2832     host_makefile_frag="config/mh-interix"
2833     ;;
2834   vax-*-ultrix2*)
2835     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2836     tentative_cc=gcc
2837     ;;
2838   *-*-solaris2*)
2839     host_makefile_frag="config/mh-solaris"
2840     ;;
2841   m68k-sun-sunos*)
2842     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2843     # without overflowing the jump tables (-J says to use a 32 bit table)
2844     tentative_cc="cc -J"
2845     ;;
2846   hppa*-hp-hpux10*)
2847     tentative_cc="cc -Wp,-H256000"
2848     host_makefile_frag="config/mh-pa-hpux10"
2849     ;;
2850   hppa*-hp-hpux* | hppa*-*-hiux*)
2851     tentative_cc="cc -Wp,-H256000"
2852     host_makefile_frag="config/mh-pa"
2853     ;;
2854   hppa*-*)
2855     host_makefile_frag="config/mh-pa"
2856     ;;
2857   *-hp-hpux* | *-*-hiux*)
2858     tentative_cc="cc -Wp,-H256000"
2859     ;;
2860   rs6000-*-lynxos*)
2861     # /bin/cc is less than useful for our purposes.  Always use GCC
2862     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2863     host_makefile_frag="config/mh-lynxrs6k"
2864     ;;
2865   powerpc-*-darwin*)
2866     host_makefile_frag="config/mh-ppc-darwin"
2867     ;;
2868   powerpc-*-aix*)
2869     host_makefile_frag="config/mh-ppc-aix"
2870     ;;
2871   rs6000-*-aix*)
2872     host_makefile_frag="config/mh-ppc-aix"
2873     ;;
2874   *-*-lynxos*)
2875     # /bin/cc is less than useful for our purposes.  Always use GCC
2876     tentative_cc="/bin/gcc"
2877     ;;
2878   *-*-sysv4*)
2879     host_makefile_frag="config/mh-sysv4"
2880     ;;
2881   # This is placed last to prevent interfering with the cases above.
2882   i[3456789]86-*-*)
2883     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2884     host_makefile_frag="config/mh-x86omitfp"
2885     ;;
2886 esac
2887 fi
2888
2889 # If we aren't going to be using gcc, see if we can extract a definition
2890 # of CC from the fragment.
2891 # Actually, use the 'pre-extracted' version above.
2892 if test -z "${CC}" && test "${build}" = "${host}" ; then
2893   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2894   found=
2895   for dir in $PATH; do
2896     test -z "$dir" && dir=.
2897     if test -f $dir/gcc; then
2898       found=yes
2899       break
2900     fi
2901   done
2902   IFS="$save_ifs"
2903   if test -z "${found}" && test -n "${tentative_cc}" ; then
2904     CC=$tentative_cc
2905   fi
2906 fi
2907
2908 if test "${build}" != "${host}" ; then
2909   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2910   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2911   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2912   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2913   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2914   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2915   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2916   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2917   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2918   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2919   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2920   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2921 else
2922   AR_FOR_BUILD="\$(AR)"
2923   AS_FOR_BUILD="\$(AS)"
2924   CC_FOR_BUILD="\$(CC)"
2925   CXX_FOR_BUILD="\$(CXX)"
2926   GCJ_FOR_BUILD="\$(GCJ)"
2927   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2928   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2929   LD_FOR_BUILD="\$(LD)"
2930   NM_FOR_BUILD="\$(NM)"
2931   RANLIB_FOR_BUILD="\$(RANLIB)"
2932   WINDRES_FOR_BUILD="\$(WINDRES)"
2933   WINDMC_FOR_BUILD="\$(WINDMC)"
2934 fi
2935
2936 ac_ext=c
2937 ac_cpp='$CPP $CPPFLAGS'
2938 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2939 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2940 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2941 if test -n "$ac_tool_prefix"; then
2942   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2943 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2944 echo "$as_me:$LINENO: checking for $ac_word" >&5
2945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2946 if test "${ac_cv_prog_CC+set}" = set; then
2947   echo $ECHO_N "(cached) $ECHO_C" >&6
2948 else
2949   if test -n "$CC"; then
2950   ac_cv_prog_CC="$CC" # Let the user override the test.
2951 else
2952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2953 for as_dir in $PATH
2954 do
2955   IFS=$as_save_IFS
2956   test -z "$as_dir" && as_dir=.
2957   for ac_exec_ext in '' $ac_executable_extensions; do
2958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2959     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2961     break 2
2962   fi
2963 done
2964 done
2965
2966 fi
2967 fi
2968 CC=$ac_cv_prog_CC
2969 if test -n "$CC"; then
2970   echo "$as_me:$LINENO: result: $CC" >&5
2971 echo "${ECHO_T}$CC" >&6
2972 else
2973   echo "$as_me:$LINENO: result: no" >&5
2974 echo "${ECHO_T}no" >&6
2975 fi
2976
2977 fi
2978 if test -z "$ac_cv_prog_CC"; then
2979   ac_ct_CC=$CC
2980   # Extract the first word of "gcc", so it can be a program name with args.
2981 set dummy gcc; ac_word=$2
2982 echo "$as_me:$LINENO: checking for $ac_word" >&5
2983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2984 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2985   echo $ECHO_N "(cached) $ECHO_C" >&6
2986 else
2987   if test -n "$ac_ct_CC"; then
2988   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2989 else
2990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2991 for as_dir in $PATH
2992 do
2993   IFS=$as_save_IFS
2994   test -z "$as_dir" && as_dir=.
2995   for ac_exec_ext in '' $ac_executable_extensions; do
2996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2997     ac_cv_prog_ac_ct_CC="gcc"
2998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2999     break 2
3000   fi
3001 done
3002 done
3003
3004 fi
3005 fi
3006 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3007 if test -n "$ac_ct_CC"; then
3008   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3009 echo "${ECHO_T}$ac_ct_CC" >&6
3010 else
3011   echo "$as_me:$LINENO: result: no" >&5
3012 echo "${ECHO_T}no" >&6
3013 fi
3014
3015   CC=$ac_ct_CC
3016 else
3017   CC="$ac_cv_prog_CC"
3018 fi
3019
3020 if test -z "$CC"; then
3021   if test -n "$ac_tool_prefix"; then
3022   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3023 set dummy ${ac_tool_prefix}cc; ac_word=$2
3024 echo "$as_me:$LINENO: checking for $ac_word" >&5
3025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3026 if test "${ac_cv_prog_CC+set}" = set; then
3027   echo $ECHO_N "(cached) $ECHO_C" >&6
3028 else
3029   if test -n "$CC"; then
3030   ac_cv_prog_CC="$CC" # Let the user override the test.
3031 else
3032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3033 for as_dir in $PATH
3034 do
3035   IFS=$as_save_IFS
3036   test -z "$as_dir" && as_dir=.
3037   for ac_exec_ext in '' $ac_executable_extensions; do
3038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3039     ac_cv_prog_CC="${ac_tool_prefix}cc"
3040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3041     break 2
3042   fi
3043 done
3044 done
3045
3046 fi
3047 fi
3048 CC=$ac_cv_prog_CC
3049 if test -n "$CC"; then
3050   echo "$as_me:$LINENO: result: $CC" >&5
3051 echo "${ECHO_T}$CC" >&6
3052 else
3053   echo "$as_me:$LINENO: result: no" >&5
3054 echo "${ECHO_T}no" >&6
3055 fi
3056
3057 fi
3058 if test -z "$ac_cv_prog_CC"; then
3059   ac_ct_CC=$CC
3060   # Extract the first word of "cc", so it can be a program name with args.
3061 set dummy cc; ac_word=$2
3062 echo "$as_me:$LINENO: checking for $ac_word" >&5
3063 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3064 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3065   echo $ECHO_N "(cached) $ECHO_C" >&6
3066 else
3067   if test -n "$ac_ct_CC"; then
3068   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3069 else
3070 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3071 for as_dir in $PATH
3072 do
3073   IFS=$as_save_IFS
3074   test -z "$as_dir" && as_dir=.
3075   for ac_exec_ext in '' $ac_executable_extensions; do
3076   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3077     ac_cv_prog_ac_ct_CC="cc"
3078     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3079     break 2
3080   fi
3081 done
3082 done
3083
3084 fi
3085 fi
3086 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3087 if test -n "$ac_ct_CC"; then
3088   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3089 echo "${ECHO_T}$ac_ct_CC" >&6
3090 else
3091   echo "$as_me:$LINENO: result: no" >&5
3092 echo "${ECHO_T}no" >&6
3093 fi
3094
3095   CC=$ac_ct_CC
3096 else
3097   CC="$ac_cv_prog_CC"
3098 fi
3099
3100 fi
3101 if test -z "$CC"; then
3102   # Extract the first word of "cc", so it can be a program name with args.
3103 set dummy cc; ac_word=$2
3104 echo "$as_me:$LINENO: checking for $ac_word" >&5
3105 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3106 if test "${ac_cv_prog_CC+set}" = set; then
3107   echo $ECHO_N "(cached) $ECHO_C" >&6
3108 else
3109   if test -n "$CC"; then
3110   ac_cv_prog_CC="$CC" # Let the user override the test.
3111 else
3112   ac_prog_rejected=no
3113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3114 for as_dir in $PATH
3115 do
3116   IFS=$as_save_IFS
3117   test -z "$as_dir" && as_dir=.
3118   for ac_exec_ext in '' $ac_executable_extensions; do
3119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3120     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3121        ac_prog_rejected=yes
3122        continue
3123      fi
3124     ac_cv_prog_CC="cc"
3125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3126     break 2
3127   fi
3128 done
3129 done
3130
3131 if test $ac_prog_rejected = yes; then
3132   # We found a bogon in the path, so make sure we never use it.
3133   set dummy $ac_cv_prog_CC
3134   shift
3135   if test $# != 0; then
3136     # We chose a different compiler from the bogus one.
3137     # However, it has the same basename, so the bogon will be chosen
3138     # first if we set CC to just the basename; use the full file name.
3139     shift
3140     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3141   fi
3142 fi
3143 fi
3144 fi
3145 CC=$ac_cv_prog_CC
3146 if test -n "$CC"; then
3147   echo "$as_me:$LINENO: result: $CC" >&5
3148 echo "${ECHO_T}$CC" >&6
3149 else
3150   echo "$as_me:$LINENO: result: no" >&5
3151 echo "${ECHO_T}no" >&6
3152 fi
3153
3154 fi
3155 if test -z "$CC"; then
3156   if test -n "$ac_tool_prefix"; then
3157   for ac_prog in cl
3158   do
3159     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3160 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3161 echo "$as_me:$LINENO: checking for $ac_word" >&5
3162 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3163 if test "${ac_cv_prog_CC+set}" = set; then
3164   echo $ECHO_N "(cached) $ECHO_C" >&6
3165 else
3166   if test -n "$CC"; then
3167   ac_cv_prog_CC="$CC" # Let the user override the test.
3168 else
3169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3170 for as_dir in $PATH
3171 do
3172   IFS=$as_save_IFS
3173   test -z "$as_dir" && as_dir=.
3174   for ac_exec_ext in '' $ac_executable_extensions; do
3175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3176     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3178     break 2
3179   fi
3180 done
3181 done
3182
3183 fi
3184 fi
3185 CC=$ac_cv_prog_CC
3186 if test -n "$CC"; then
3187   echo "$as_me:$LINENO: result: $CC" >&5
3188 echo "${ECHO_T}$CC" >&6
3189 else
3190   echo "$as_me:$LINENO: result: no" >&5
3191 echo "${ECHO_T}no" >&6
3192 fi
3193
3194     test -n "$CC" && break
3195   done
3196 fi
3197 if test -z "$CC"; then
3198   ac_ct_CC=$CC
3199   for ac_prog in cl
3200 do
3201   # Extract the first word of "$ac_prog", so it can be a program name with args.
3202 set dummy $ac_prog; ac_word=$2
3203 echo "$as_me:$LINENO: checking for $ac_word" >&5
3204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3205 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3206   echo $ECHO_N "(cached) $ECHO_C" >&6
3207 else
3208   if test -n "$ac_ct_CC"; then
3209   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3210 else
3211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3212 for as_dir in $PATH
3213 do
3214   IFS=$as_save_IFS
3215   test -z "$as_dir" && as_dir=.
3216   for ac_exec_ext in '' $ac_executable_extensions; do
3217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3218     ac_cv_prog_ac_ct_CC="$ac_prog"
3219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3220     break 2
3221   fi
3222 done
3223 done
3224
3225 fi
3226 fi
3227 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3228 if test -n "$ac_ct_CC"; then
3229   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3230 echo "${ECHO_T}$ac_ct_CC" >&6
3231 else
3232   echo "$as_me:$LINENO: result: no" >&5
3233 echo "${ECHO_T}no" >&6
3234 fi
3235
3236   test -n "$ac_ct_CC" && break
3237 done
3238
3239   CC=$ac_ct_CC
3240 fi
3241
3242 fi
3243
3244
3245 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3246 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3247 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3248 See \`config.log' for more details." >&5
3249 echo "$as_me: error: no acceptable C compiler found in \$PATH
3250 See \`config.log' for more details." >&2;}
3251    { (exit 1); exit 1; }; }; }
3252
3253 # Provide some information about the compiler.
3254 echo "$as_me:$LINENO:" \
3255      "checking for C compiler version" >&5
3256 ac_compiler=`set X $ac_compile; echo $2`
3257 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3258   (eval $ac_compiler --version </dev/null >&5) 2>&5
3259   ac_status=$?
3260   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3261   (exit $ac_status); }
3262 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3263   (eval $ac_compiler -v </dev/null >&5) 2>&5
3264   ac_status=$?
3265   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3266   (exit $ac_status); }
3267 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3268   (eval $ac_compiler -V </dev/null >&5) 2>&5
3269   ac_status=$?
3270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3271   (exit $ac_status); }
3272
3273 cat >conftest.$ac_ext <<_ACEOF
3274 /* confdefs.h.  */
3275 _ACEOF
3276 cat confdefs.h >>conftest.$ac_ext
3277 cat >>conftest.$ac_ext <<_ACEOF
3278 /* end confdefs.h.  */
3279
3280 int
3281 main ()
3282 {
3283
3284   ;
3285   return 0;
3286 }
3287 _ACEOF
3288 ac_clean_files_save=$ac_clean_files
3289 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3290 # Try to create an executable without -o first, disregard a.out.
3291 # It will help us diagnose broken compilers, and finding out an intuition
3292 # of exeext.
3293 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3294 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3295 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3296 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3297   (eval $ac_link_default) 2>&5
3298   ac_status=$?
3299   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3300   (exit $ac_status); }; then
3301   # Find the output, starting from the most likely.  This scheme is
3302 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3303 # resort.
3304
3305 # Be careful to initialize this variable, since it used to be cached.
3306 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3307 ac_cv_exeext=
3308 # b.out is created by i960 compilers.
3309 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3310 do
3311   test -f "$ac_file" || continue
3312   case $ac_file in
3313     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3314         ;;
3315     conftest.$ac_ext )
3316         # This is the source file.
3317         ;;
3318     [ab].out )
3319         # We found the default executable, but exeext='' is most
3320         # certainly right.
3321         break;;
3322     *.* )
3323         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3324         # FIXME: I believe we export ac_cv_exeext for Libtool,
3325         # but it would be cool to find out if it's true.  Does anybody
3326         # maintain Libtool? --akim.
3327         export ac_cv_exeext
3328         break;;
3329     * )
3330         break;;
3331   esac
3332 done
3333 else
3334   echo "$as_me: failed program was:" >&5
3335 sed 's/^/| /' conftest.$ac_ext >&5
3336
3337 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3338 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3339 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3340 See \`config.log' for more details." >&5
3341 echo "$as_me: error: C compiler cannot create executables
3342 See \`config.log' for more details." >&2;}
3343    { (exit 77); exit 77; }; }; }
3344 fi
3345
3346 ac_exeext=$ac_cv_exeext
3347 echo "$as_me:$LINENO: result: $ac_file" >&5
3348 echo "${ECHO_T}$ac_file" >&6
3349
3350 # Check the compiler produces executables we can run.  If not, either
3351 # the compiler is broken, or we cross compile.
3352 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3353 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3354 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3355 # If not cross compiling, check that we can run a simple program.
3356 if test "$cross_compiling" != yes; then
3357   if { ac_try='./$ac_file'
3358   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3359   (eval $ac_try) 2>&5
3360   ac_status=$?
3361   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3362   (exit $ac_status); }; }; then
3363     cross_compiling=no
3364   else
3365     if test "$cross_compiling" = maybe; then
3366         cross_compiling=yes
3367     else
3368         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3369 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3370 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3371 If you meant to cross compile, use \`--host'.
3372 See \`config.log' for more details." >&5
3373 echo "$as_me: error: cannot run C compiled programs.
3374 If you meant to cross compile, use \`--host'.
3375 See \`config.log' for more details." >&2;}
3376    { (exit 1); exit 1; }; }; }
3377     fi
3378   fi
3379 fi
3380 echo "$as_me:$LINENO: result: yes" >&5
3381 echo "${ECHO_T}yes" >&6
3382
3383 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3384 ac_clean_files=$ac_clean_files_save
3385 # Check the compiler produces executables we can run.  If not, either
3386 # the compiler is broken, or we cross compile.
3387 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3388 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3389 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3390 echo "${ECHO_T}$cross_compiling" >&6
3391
3392 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3393 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3394 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3395   (eval $ac_link) 2>&5
3396   ac_status=$?
3397   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3398   (exit $ac_status); }; then
3399   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3400 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3401 # work properly (i.e., refer to `conftest.exe'), while it won't with
3402 # `rm'.
3403 for ac_file in conftest.exe conftest conftest.*; do
3404   test -f "$ac_file" || continue
3405   case $ac_file in
3406     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3407     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3408           export ac_cv_exeext
3409           break;;
3410     * ) break;;
3411   esac
3412 done
3413 else
3414   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3415 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3416 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3417 See \`config.log' for more details." >&5
3418 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3419 See \`config.log' for more details." >&2;}
3420    { (exit 1); exit 1; }; }; }
3421 fi
3422
3423 rm -f conftest$ac_cv_exeext
3424 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3425 echo "${ECHO_T}$ac_cv_exeext" >&6
3426
3427 rm -f conftest.$ac_ext
3428 EXEEXT=$ac_cv_exeext
3429 ac_exeext=$EXEEXT
3430 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3431 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3432 if test "${ac_cv_objext+set}" = set; then
3433   echo $ECHO_N "(cached) $ECHO_C" >&6
3434 else
3435   cat >conftest.$ac_ext <<_ACEOF
3436 /* confdefs.h.  */
3437 _ACEOF
3438 cat confdefs.h >>conftest.$ac_ext
3439 cat >>conftest.$ac_ext <<_ACEOF
3440 /* end confdefs.h.  */
3441
3442 int
3443 main ()
3444 {
3445
3446   ;
3447   return 0;
3448 }
3449 _ACEOF
3450 rm -f conftest.o conftest.obj
3451 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3452   (eval $ac_compile) 2>&5
3453   ac_status=$?
3454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3455   (exit $ac_status); }; then
3456   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3457   case $ac_file in
3458     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3459     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3460        break;;
3461   esac
3462 done
3463 else
3464   echo "$as_me: failed program was:" >&5
3465 sed 's/^/| /' conftest.$ac_ext >&5
3466
3467 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3468 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3469 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3470 See \`config.log' for more details." >&5
3471 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3472 See \`config.log' for more details." >&2;}
3473    { (exit 1); exit 1; }; }; }
3474 fi
3475
3476 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3477 fi
3478 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3479 echo "${ECHO_T}$ac_cv_objext" >&6
3480 OBJEXT=$ac_cv_objext
3481 ac_objext=$OBJEXT
3482 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3483 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3484 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3485   echo $ECHO_N "(cached) $ECHO_C" >&6
3486 else
3487   cat >conftest.$ac_ext <<_ACEOF
3488 /* confdefs.h.  */
3489 _ACEOF
3490 cat confdefs.h >>conftest.$ac_ext
3491 cat >>conftest.$ac_ext <<_ACEOF
3492 /* end confdefs.h.  */
3493
3494 int
3495 main ()
3496 {
3497 #ifndef __GNUC__
3498        choke me
3499 #endif
3500
3501   ;
3502   return 0;
3503 }
3504 _ACEOF
3505 rm -f conftest.$ac_objext
3506 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3507   (eval $ac_compile) 2>conftest.er1
3508   ac_status=$?
3509   grep -v '^ *+' conftest.er1 >conftest.err
3510   rm -f conftest.er1
3511   cat conftest.err >&5
3512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513   (exit $ac_status); } &&
3514          { ac_try='test -z "$ac_c_werror_flag"
3515                          || test ! -s conftest.err'
3516   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3517   (eval $ac_try) 2>&5
3518   ac_status=$?
3519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3520   (exit $ac_status); }; } &&
3521          { ac_try='test -s conftest.$ac_objext'
3522   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3523   (eval $ac_try) 2>&5
3524   ac_status=$?
3525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3526   (exit $ac_status); }; }; then
3527   ac_compiler_gnu=yes
3528 else
3529   echo "$as_me: failed program was:" >&5
3530 sed 's/^/| /' conftest.$ac_ext >&5
3531
3532 ac_compiler_gnu=no
3533 fi
3534 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3535 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3536
3537 fi
3538 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3539 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3540 GCC=`test $ac_compiler_gnu = yes && echo yes`
3541 ac_test_CFLAGS=${CFLAGS+set}
3542 ac_save_CFLAGS=$CFLAGS
3543 CFLAGS="-g"
3544 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3545 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3546 if test "${ac_cv_prog_cc_g+set}" = set; then
3547   echo $ECHO_N "(cached) $ECHO_C" >&6
3548 else
3549   cat >conftest.$ac_ext <<_ACEOF
3550 /* confdefs.h.  */
3551 _ACEOF
3552 cat confdefs.h >>conftest.$ac_ext
3553 cat >>conftest.$ac_ext <<_ACEOF
3554 /* end confdefs.h.  */
3555
3556 int
3557 main ()
3558 {
3559
3560   ;
3561   return 0;
3562 }
3563 _ACEOF
3564 rm -f conftest.$ac_objext
3565 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3566   (eval $ac_compile) 2>conftest.er1
3567   ac_status=$?
3568   grep -v '^ *+' conftest.er1 >conftest.err
3569   rm -f conftest.er1
3570   cat conftest.err >&5
3571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3572   (exit $ac_status); } &&
3573          { ac_try='test -z "$ac_c_werror_flag"
3574                          || test ! -s conftest.err'
3575   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3576   (eval $ac_try) 2>&5
3577   ac_status=$?
3578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3579   (exit $ac_status); }; } &&
3580          { ac_try='test -s conftest.$ac_objext'
3581   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3582   (eval $ac_try) 2>&5
3583   ac_status=$?
3584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3585   (exit $ac_status); }; }; then
3586   ac_cv_prog_cc_g=yes
3587 else
3588   echo "$as_me: failed program was:" >&5
3589 sed 's/^/| /' conftest.$ac_ext >&5
3590
3591 ac_cv_prog_cc_g=no
3592 fi
3593 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3594 fi
3595 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3596 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3597 if test "$ac_test_CFLAGS" = set; then
3598   CFLAGS=$ac_save_CFLAGS
3599 elif test $ac_cv_prog_cc_g = yes; then
3600   if test "$GCC" = yes; then
3601     CFLAGS="-g -O2"
3602   else
3603     CFLAGS="-g"
3604   fi
3605 else
3606   if test "$GCC" = yes; then
3607     CFLAGS="-O2"
3608   else
3609     CFLAGS=
3610   fi
3611 fi
3612 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3613 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3614 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3615   echo $ECHO_N "(cached) $ECHO_C" >&6
3616 else
3617   ac_cv_prog_cc_stdc=no
3618 ac_save_CC=$CC
3619 cat >conftest.$ac_ext <<_ACEOF
3620 /* confdefs.h.  */
3621 _ACEOF
3622 cat confdefs.h >>conftest.$ac_ext
3623 cat >>conftest.$ac_ext <<_ACEOF
3624 /* end confdefs.h.  */
3625 #include <stdarg.h>
3626 #include <stdio.h>
3627 #include <sys/types.h>
3628 #include <sys/stat.h>
3629 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3630 struct buf { int x; };
3631 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3632 static char *e (p, i)
3633      char **p;
3634      int i;
3635 {
3636   return p[i];
3637 }
3638 static char *f (char * (*g) (char **, int), char **p, ...)
3639 {
3640   char *s;
3641   va_list v;
3642   va_start (v,p);
3643   s = g (p, va_arg (v,int));
3644   va_end (v);
3645   return s;
3646 }
3647
3648 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3649    function prototypes and stuff, but not '\xHH' hex character constants.
3650    These don't provoke an error unfortunately, instead are silently treated
3651    as 'x'.  The following induces an error, until -std1 is added to get
3652    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3653    array size at least.  It's necessary to write '\x00'==0 to get something
3654    that's true only with -std1.  */
3655 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3656
3657 int test (int i, double x);
3658 struct s1 {int (*f) (int a);};
3659 struct s2 {int (*f) (double a);};
3660 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3661 int argc;
3662 char **argv;
3663 int
3664 main ()
3665 {
3666 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3667   ;
3668   return 0;
3669 }
3670 _ACEOF
3671 # Don't try gcc -ansi; that turns off useful extensions and
3672 # breaks some systems' header files.
3673 # AIX                   -qlanglvl=ansi
3674 # Ultrix and OSF/1      -std1
3675 # HP-UX 10.20 and later -Ae
3676 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3677 # SVR4                  -Xc -D__EXTENSIONS__
3678 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3679 do
3680   CC="$ac_save_CC $ac_arg"
3681   rm -f conftest.$ac_objext
3682 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3683   (eval $ac_compile) 2>conftest.er1
3684   ac_status=$?
3685   grep -v '^ *+' conftest.er1 >conftest.err
3686   rm -f conftest.er1
3687   cat conftest.err >&5
3688   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3689   (exit $ac_status); } &&
3690          { ac_try='test -z "$ac_c_werror_flag"
3691                          || test ! -s conftest.err'
3692   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3693   (eval $ac_try) 2>&5
3694   ac_status=$?
3695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3696   (exit $ac_status); }; } &&
3697          { ac_try='test -s conftest.$ac_objext'
3698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3699   (eval $ac_try) 2>&5
3700   ac_status=$?
3701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3702   (exit $ac_status); }; }; then
3703   ac_cv_prog_cc_stdc=$ac_arg
3704 break
3705 else
3706   echo "$as_me: failed program was:" >&5
3707 sed 's/^/| /' conftest.$ac_ext >&5
3708
3709 fi
3710 rm -f conftest.err conftest.$ac_objext
3711 done
3712 rm -f conftest.$ac_ext conftest.$ac_objext
3713 CC=$ac_save_CC
3714
3715 fi
3716
3717 case "x$ac_cv_prog_cc_stdc" in
3718   x|xno)
3719     echo "$as_me:$LINENO: result: none needed" >&5
3720 echo "${ECHO_T}none needed" >&6 ;;
3721   *)
3722     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3723 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3724     CC="$CC $ac_cv_prog_cc_stdc" ;;
3725 esac
3726
3727 # Some people use a C++ compiler to compile C.  Since we use `exit',
3728 # in C++ we need to declare it.  In case someone uses the same compiler
3729 # for both compiling C and C++ we need to have the C++ compiler decide
3730 # the declaration of exit, since it's the most demanding environment.
3731 cat >conftest.$ac_ext <<_ACEOF
3732 #ifndef __cplusplus
3733   choke me
3734 #endif
3735 _ACEOF
3736 rm -f conftest.$ac_objext
3737 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3738   (eval $ac_compile) 2>conftest.er1
3739   ac_status=$?
3740   grep -v '^ *+' conftest.er1 >conftest.err
3741   rm -f conftest.er1
3742   cat conftest.err >&5
3743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3744   (exit $ac_status); } &&
3745          { ac_try='test -z "$ac_c_werror_flag"
3746                          || test ! -s conftest.err'
3747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3748   (eval $ac_try) 2>&5
3749   ac_status=$?
3750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3751   (exit $ac_status); }; } &&
3752          { ac_try='test -s conftest.$ac_objext'
3753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3754   (eval $ac_try) 2>&5
3755   ac_status=$?
3756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3757   (exit $ac_status); }; }; then
3758   for ac_declaration in \
3759    '' \
3760    'extern "C" void std::exit (int) throw (); using std::exit;' \
3761    'extern "C" void std::exit (int); using std::exit;' \
3762    'extern "C" void exit (int) throw ();' \
3763    'extern "C" void exit (int);' \
3764    'void exit (int);'
3765 do
3766   cat >conftest.$ac_ext <<_ACEOF
3767 /* confdefs.h.  */
3768 _ACEOF
3769 cat confdefs.h >>conftest.$ac_ext
3770 cat >>conftest.$ac_ext <<_ACEOF
3771 /* end confdefs.h.  */
3772 $ac_declaration
3773 #include <stdlib.h>
3774 int
3775 main ()
3776 {
3777 exit (42);
3778   ;
3779   return 0;
3780 }
3781 _ACEOF
3782 rm -f conftest.$ac_objext
3783 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3784   (eval $ac_compile) 2>conftest.er1
3785   ac_status=$?
3786   grep -v '^ *+' conftest.er1 >conftest.err
3787   rm -f conftest.er1
3788   cat conftest.err >&5
3789   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3790   (exit $ac_status); } &&
3791          { ac_try='test -z "$ac_c_werror_flag"
3792                          || test ! -s conftest.err'
3793   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3794   (eval $ac_try) 2>&5
3795   ac_status=$?
3796   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3797   (exit $ac_status); }; } &&
3798          { ac_try='test -s conftest.$ac_objext'
3799   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3800   (eval $ac_try) 2>&5
3801   ac_status=$?
3802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3803   (exit $ac_status); }; }; then
3804   :
3805 else
3806   echo "$as_me: failed program was:" >&5
3807 sed 's/^/| /' conftest.$ac_ext >&5
3808
3809 continue
3810 fi
3811 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3812   cat >conftest.$ac_ext <<_ACEOF
3813 /* confdefs.h.  */
3814 _ACEOF
3815 cat confdefs.h >>conftest.$ac_ext
3816 cat >>conftest.$ac_ext <<_ACEOF
3817 /* end confdefs.h.  */
3818 $ac_declaration
3819 int
3820 main ()
3821 {
3822 exit (42);
3823   ;
3824   return 0;
3825 }
3826 _ACEOF
3827 rm -f conftest.$ac_objext
3828 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3829   (eval $ac_compile) 2>conftest.er1
3830   ac_status=$?
3831   grep -v '^ *+' conftest.er1 >conftest.err
3832   rm -f conftest.er1
3833   cat conftest.err >&5
3834   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3835   (exit $ac_status); } &&
3836          { ac_try='test -z "$ac_c_werror_flag"
3837                          || test ! -s conftest.err'
3838   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3839   (eval $ac_try) 2>&5
3840   ac_status=$?
3841   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3842   (exit $ac_status); }; } &&
3843          { ac_try='test -s conftest.$ac_objext'
3844   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3845   (eval $ac_try) 2>&5
3846   ac_status=$?
3847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3848   (exit $ac_status); }; }; then
3849   break
3850 else
3851   echo "$as_me: failed program was:" >&5
3852 sed 's/^/| /' conftest.$ac_ext >&5
3853
3854 fi
3855 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3856 done
3857 rm -f conftest*
3858 if test -n "$ac_declaration"; then
3859   echo '#ifdef __cplusplus' >>confdefs.h
3860   echo $ac_declaration      >>confdefs.h
3861   echo '#endif'             >>confdefs.h
3862 fi
3863
3864 else
3865   echo "$as_me: failed program was:" >&5
3866 sed 's/^/| /' conftest.$ac_ext >&5
3867
3868 fi
3869 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3870 ac_ext=c
3871 ac_cpp='$CPP $CPPFLAGS'
3872 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3873 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3874 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3875
3876 ac_ext=cc
3877 ac_cpp='$CXXCPP $CPPFLAGS'
3878 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3879 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3880 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3881 if test -n "$ac_tool_prefix"; then
3882   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3883   do
3884     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3885 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3886 echo "$as_me:$LINENO: checking for $ac_word" >&5
3887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3888 if test "${ac_cv_prog_CXX+set}" = set; then
3889   echo $ECHO_N "(cached) $ECHO_C" >&6
3890 else
3891   if test -n "$CXX"; then
3892   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3893 else
3894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3895 for as_dir in $PATH
3896 do
3897   IFS=$as_save_IFS
3898   test -z "$as_dir" && as_dir=.
3899   for ac_exec_ext in '' $ac_executable_extensions; do
3900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3901     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3903     break 2
3904   fi
3905 done
3906 done
3907
3908 fi
3909 fi
3910 CXX=$ac_cv_prog_CXX
3911 if test -n "$CXX"; then
3912   echo "$as_me:$LINENO: result: $CXX" >&5
3913 echo "${ECHO_T}$CXX" >&6
3914 else
3915   echo "$as_me:$LINENO: result: no" >&5
3916 echo "${ECHO_T}no" >&6
3917 fi
3918
3919     test -n "$CXX" && break
3920   done
3921 fi
3922 if test -z "$CXX"; then
3923   ac_ct_CXX=$CXX
3924   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3925 do
3926   # Extract the first word of "$ac_prog", so it can be a program name with args.
3927 set dummy $ac_prog; ac_word=$2
3928 echo "$as_me:$LINENO: checking for $ac_word" >&5
3929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3930 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3931   echo $ECHO_N "(cached) $ECHO_C" >&6
3932 else
3933   if test -n "$ac_ct_CXX"; then
3934   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3935 else
3936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3937 for as_dir in $PATH
3938 do
3939   IFS=$as_save_IFS
3940   test -z "$as_dir" && as_dir=.
3941   for ac_exec_ext in '' $ac_executable_extensions; do
3942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3943     ac_cv_prog_ac_ct_CXX="$ac_prog"
3944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3945     break 2
3946   fi
3947 done
3948 done
3949
3950 fi
3951 fi
3952 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3953 if test -n "$ac_ct_CXX"; then
3954   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3955 echo "${ECHO_T}$ac_ct_CXX" >&6
3956 else
3957   echo "$as_me:$LINENO: result: no" >&5
3958 echo "${ECHO_T}no" >&6
3959 fi
3960
3961   test -n "$ac_ct_CXX" && break
3962 done
3963 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3964
3965   CXX=$ac_ct_CXX
3966 fi
3967
3968
3969 # Provide some information about the compiler.
3970 echo "$as_me:$LINENO:" \
3971      "checking for C++ compiler version" >&5
3972 ac_compiler=`set X $ac_compile; echo $2`
3973 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3974   (eval $ac_compiler --version </dev/null >&5) 2>&5
3975   ac_status=$?
3976   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3977   (exit $ac_status); }
3978 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3979   (eval $ac_compiler -v </dev/null >&5) 2>&5
3980   ac_status=$?
3981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3982   (exit $ac_status); }
3983 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3984   (eval $ac_compiler -V </dev/null >&5) 2>&5
3985   ac_status=$?
3986   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3987   (exit $ac_status); }
3988
3989 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3990 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3991 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3992   echo $ECHO_N "(cached) $ECHO_C" >&6
3993 else
3994   cat >conftest.$ac_ext <<_ACEOF
3995 /* confdefs.h.  */
3996 _ACEOF
3997 cat confdefs.h >>conftest.$ac_ext
3998 cat >>conftest.$ac_ext <<_ACEOF
3999 /* end confdefs.h.  */
4000
4001 int
4002 main ()
4003 {
4004 #ifndef __GNUC__
4005        choke me
4006 #endif
4007
4008   ;
4009   return 0;
4010 }
4011 _ACEOF
4012 rm -f conftest.$ac_objext
4013 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4014   (eval $ac_compile) 2>conftest.er1
4015   ac_status=$?
4016   grep -v '^ *+' conftest.er1 >conftest.err
4017   rm -f conftest.er1
4018   cat conftest.err >&5
4019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020   (exit $ac_status); } &&
4021          { ac_try='test -z "$ac_cxx_werror_flag"
4022                          || test ! -s conftest.err'
4023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4024   (eval $ac_try) 2>&5
4025   ac_status=$?
4026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4027   (exit $ac_status); }; } &&
4028          { ac_try='test -s conftest.$ac_objext'
4029   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4030   (eval $ac_try) 2>&5
4031   ac_status=$?
4032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4033   (exit $ac_status); }; }; then
4034   ac_compiler_gnu=yes
4035 else
4036   echo "$as_me: failed program was:" >&5
4037 sed 's/^/| /' conftest.$ac_ext >&5
4038
4039 ac_compiler_gnu=no
4040 fi
4041 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4042 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4043
4044 fi
4045 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4046 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4047 GXX=`test $ac_compiler_gnu = yes && echo yes`
4048 ac_test_CXXFLAGS=${CXXFLAGS+set}
4049 ac_save_CXXFLAGS=$CXXFLAGS
4050 CXXFLAGS="-g"
4051 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4052 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4053 if test "${ac_cv_prog_cxx_g+set}" = set; then
4054   echo $ECHO_N "(cached) $ECHO_C" >&6
4055 else
4056   cat >conftest.$ac_ext <<_ACEOF
4057 /* confdefs.h.  */
4058 _ACEOF
4059 cat confdefs.h >>conftest.$ac_ext
4060 cat >>conftest.$ac_ext <<_ACEOF
4061 /* end confdefs.h.  */
4062
4063 int
4064 main ()
4065 {
4066
4067   ;
4068   return 0;
4069 }
4070 _ACEOF
4071 rm -f conftest.$ac_objext
4072 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4073   (eval $ac_compile) 2>conftest.er1
4074   ac_status=$?
4075   grep -v '^ *+' conftest.er1 >conftest.err
4076   rm -f conftest.er1
4077   cat conftest.err >&5
4078   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4079   (exit $ac_status); } &&
4080          { ac_try='test -z "$ac_cxx_werror_flag"
4081                          || test ! -s conftest.err'
4082   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4083   (eval $ac_try) 2>&5
4084   ac_status=$?
4085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4086   (exit $ac_status); }; } &&
4087          { ac_try='test -s conftest.$ac_objext'
4088   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4089   (eval $ac_try) 2>&5
4090   ac_status=$?
4091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4092   (exit $ac_status); }; }; then
4093   ac_cv_prog_cxx_g=yes
4094 else
4095   echo "$as_me: failed program was:" >&5
4096 sed 's/^/| /' conftest.$ac_ext >&5
4097
4098 ac_cv_prog_cxx_g=no
4099 fi
4100 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4101 fi
4102 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4103 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4104 if test "$ac_test_CXXFLAGS" = set; then
4105   CXXFLAGS=$ac_save_CXXFLAGS
4106 elif test $ac_cv_prog_cxx_g = yes; then
4107   if test "$GXX" = yes; then
4108     CXXFLAGS="-g -O2"
4109   else
4110     CXXFLAGS="-g"
4111   fi
4112 else
4113   if test "$GXX" = yes; then
4114     CXXFLAGS="-O2"
4115   else
4116     CXXFLAGS=
4117   fi
4118 fi
4119 for ac_declaration in \
4120    '' \
4121    'extern "C" void std::exit (int) throw (); using std::exit;' \
4122    'extern "C" void std::exit (int); using std::exit;' \
4123    'extern "C" void exit (int) throw ();' \
4124    'extern "C" void exit (int);' \
4125    'void exit (int);'
4126 do
4127   cat >conftest.$ac_ext <<_ACEOF
4128 /* confdefs.h.  */
4129 _ACEOF
4130 cat confdefs.h >>conftest.$ac_ext
4131 cat >>conftest.$ac_ext <<_ACEOF
4132 /* end confdefs.h.  */
4133 $ac_declaration
4134 #include <stdlib.h>
4135 int
4136 main ()
4137 {
4138 exit (42);
4139   ;
4140   return 0;
4141 }
4142 _ACEOF
4143 rm -f conftest.$ac_objext
4144 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4145   (eval $ac_compile) 2>conftest.er1
4146   ac_status=$?
4147   grep -v '^ *+' conftest.er1 >conftest.err
4148   rm -f conftest.er1
4149   cat conftest.err >&5
4150   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4151   (exit $ac_status); } &&
4152          { ac_try='test -z "$ac_cxx_werror_flag"
4153                          || test ! -s conftest.err'
4154   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4155   (eval $ac_try) 2>&5
4156   ac_status=$?
4157   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4158   (exit $ac_status); }; } &&
4159          { ac_try='test -s conftest.$ac_objext'
4160   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4161   (eval $ac_try) 2>&5
4162   ac_status=$?
4163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4164   (exit $ac_status); }; }; then
4165   :
4166 else
4167   echo "$as_me: failed program was:" >&5
4168 sed 's/^/| /' conftest.$ac_ext >&5
4169
4170 continue
4171 fi
4172 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4173   cat >conftest.$ac_ext <<_ACEOF
4174 /* confdefs.h.  */
4175 _ACEOF
4176 cat confdefs.h >>conftest.$ac_ext
4177 cat >>conftest.$ac_ext <<_ACEOF
4178 /* end confdefs.h.  */
4179 $ac_declaration
4180 int
4181 main ()
4182 {
4183 exit (42);
4184   ;
4185   return 0;
4186 }
4187 _ACEOF
4188 rm -f conftest.$ac_objext
4189 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4190   (eval $ac_compile) 2>conftest.er1
4191   ac_status=$?
4192   grep -v '^ *+' conftest.er1 >conftest.err
4193   rm -f conftest.er1
4194   cat conftest.err >&5
4195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4196   (exit $ac_status); } &&
4197          { ac_try='test -z "$ac_cxx_werror_flag"
4198                          || test ! -s conftest.err'
4199   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4200   (eval $ac_try) 2>&5
4201   ac_status=$?
4202   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4203   (exit $ac_status); }; } &&
4204          { ac_try='test -s conftest.$ac_objext'
4205   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4206   (eval $ac_try) 2>&5
4207   ac_status=$?
4208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4209   (exit $ac_status); }; }; then
4210   break
4211 else
4212   echo "$as_me: failed program was:" >&5
4213 sed 's/^/| /' conftest.$ac_ext >&5
4214
4215 fi
4216 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4217 done
4218 rm -f conftest*
4219 if test -n "$ac_declaration"; then
4220   echo '#ifdef __cplusplus' >>confdefs.h
4221   echo $ac_declaration      >>confdefs.h
4222   echo '#endif'             >>confdefs.h
4223 fi
4224
4225 ac_ext=c
4226 ac_cpp='$CPP $CPPFLAGS'
4227 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4228 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4229 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4230
4231
4232 # We must set the default linker to the linker used by gcc for the correct
4233 # operation of libtool.  If LD is not defined and we are using gcc, try to
4234 # set the LD default to the ld used by gcc.
4235 if test -z "$LD"; then
4236   if test "$GCC" = yes; then
4237     case $build in
4238     *-*-mingw*)
4239       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4240     *)
4241       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4242     esac
4243     case $gcc_prog_ld in
4244     # Accept absolute paths.
4245     [\\/]* | [A-Za-z]:[\\/]*)
4246       LD="$gcc_prog_ld" ;;
4247     esac
4248   fi
4249 fi
4250
4251
4252
4253
4254 if test -n "$ac_tool_prefix"; then
4255   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4256 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4257 echo "$as_me:$LINENO: checking for $ac_word" >&5
4258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4259 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4260   echo $ECHO_N "(cached) $ECHO_C" >&6
4261 else
4262   if test -n "$GNATBIND"; then
4263   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4264 else
4265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4266 for as_dir in $PATH
4267 do
4268   IFS=$as_save_IFS
4269   test -z "$as_dir" && as_dir=.
4270   for ac_exec_ext in '' $ac_executable_extensions; do
4271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4272     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4274     break 2
4275   fi
4276 done
4277 done
4278
4279 fi
4280 fi
4281 GNATBIND=$ac_cv_prog_GNATBIND
4282 if test -n "$GNATBIND"; then
4283   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4284 echo "${ECHO_T}$GNATBIND" >&6
4285 else
4286   echo "$as_me:$LINENO: result: no" >&5
4287 echo "${ECHO_T}no" >&6
4288 fi
4289
4290 fi
4291 if test -z "$ac_cv_prog_GNATBIND"; then
4292   ac_ct_GNATBIND=$GNATBIND
4293   # Extract the first word of "gnatbind", so it can be a program name with args.
4294 set dummy gnatbind; ac_word=$2
4295 echo "$as_me:$LINENO: checking for $ac_word" >&5
4296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4297 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4298   echo $ECHO_N "(cached) $ECHO_C" >&6
4299 else
4300   if test -n "$ac_ct_GNATBIND"; then
4301   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4302 else
4303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4304 for as_dir in $PATH
4305 do
4306   IFS=$as_save_IFS
4307   test -z "$as_dir" && as_dir=.
4308   for ac_exec_ext in '' $ac_executable_extensions; do
4309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4310     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4312     break 2
4313   fi
4314 done
4315 done
4316
4317   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4318 fi
4319 fi
4320 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4321 if test -n "$ac_ct_GNATBIND"; then
4322   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4323 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4324 else
4325   echo "$as_me:$LINENO: result: no" >&5
4326 echo "${ECHO_T}no" >&6
4327 fi
4328
4329   GNATBIND=$ac_ct_GNATBIND
4330 else
4331   GNATBIND="$ac_cv_prog_GNATBIND"
4332 fi
4333
4334 if test -n "$ac_tool_prefix"; then
4335   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4336 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4337 echo "$as_me:$LINENO: checking for $ac_word" >&5
4338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4339 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4340   echo $ECHO_N "(cached) $ECHO_C" >&6
4341 else
4342   if test -n "$GNATMAKE"; then
4343   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4344 else
4345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4346 for as_dir in $PATH
4347 do
4348   IFS=$as_save_IFS
4349   test -z "$as_dir" && as_dir=.
4350   for ac_exec_ext in '' $ac_executable_extensions; do
4351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4352     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4354     break 2
4355   fi
4356 done
4357 done
4358
4359 fi
4360 fi
4361 GNATMAKE=$ac_cv_prog_GNATMAKE
4362 if test -n "$GNATMAKE"; then
4363   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4364 echo "${ECHO_T}$GNATMAKE" >&6
4365 else
4366   echo "$as_me:$LINENO: result: no" >&5
4367 echo "${ECHO_T}no" >&6
4368 fi
4369
4370 fi
4371 if test -z "$ac_cv_prog_GNATMAKE"; then
4372   ac_ct_GNATMAKE=$GNATMAKE
4373   # Extract the first word of "gnatmake", so it can be a program name with args.
4374 set dummy gnatmake; ac_word=$2
4375 echo "$as_me:$LINENO: checking for $ac_word" >&5
4376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4377 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4378   echo $ECHO_N "(cached) $ECHO_C" >&6
4379 else
4380   if test -n "$ac_ct_GNATMAKE"; then
4381   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4382 else
4383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4384 for as_dir in $PATH
4385 do
4386   IFS=$as_save_IFS
4387   test -z "$as_dir" && as_dir=.
4388   for ac_exec_ext in '' $ac_executable_extensions; do
4389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4390     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4392     break 2
4393   fi
4394 done
4395 done
4396
4397   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4398 fi
4399 fi
4400 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4401 if test -n "$ac_ct_GNATMAKE"; then
4402   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4403 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4404 else
4405   echo "$as_me:$LINENO: result: no" >&5
4406 echo "${ECHO_T}no" >&6
4407 fi
4408
4409   GNATMAKE=$ac_ct_GNATMAKE
4410 else
4411   GNATMAKE="$ac_cv_prog_GNATMAKE"
4412 fi
4413
4414 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4415 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4416 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4417   echo $ECHO_N "(cached) $ECHO_C" >&6
4418 else
4419   cat >conftest.adb <<EOF
4420 procedure conftest is begin null; end conftest;
4421 EOF
4422 acx_cv_cc_gcc_supports_ada=no
4423 # There is a bug in old released versions of GCC which causes the
4424 # driver to exit successfully when the appropriate language module
4425 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4426 # Therefore we must check for the error message as well as an
4427 # unsuccessful exit.
4428 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4429 # given a .adb file, but produce no object file.  So we must check
4430 # if an object file was really produced to guard against this.
4431 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4432 if test x"$errors" = x && test -f conftest.$ac_objext; then
4433   acx_cv_cc_gcc_supports_ada=yes
4434 fi
4435 rm -f conftest.*
4436 fi
4437 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4438 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4439
4440 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4441   have_gnat=yes
4442 else
4443   have_gnat=no
4444 fi
4445
4446 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4447 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4448 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4449   echo $ECHO_N "(cached) $ECHO_C" >&6
4450 else
4451    echo abfoo >t1
4452   echo cdfoo >t2
4453   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4454   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4455     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4456       :
4457     else
4458       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4459     fi
4460   fi
4461   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4462     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4463       :
4464     else
4465       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4466     fi
4467   fi
4468   rm t1 t2
4469
4470 fi
4471 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4472 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4473 do_compare="$gcc_cv_prog_cmp_skip"
4474
4475
4476
4477 # Check for GMP and MPFR
4478 gmplibs="-lmpfr -lgmp"
4479 gmpinc=
4480 have_gmp=no
4481
4482 # Specify a location for mpfr
4483 # check for this first so it ends up on the link line before gmp.
4484
4485 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4486 if test "${with_mpfr_dir+set}" = set; then
4487   withval="$with_mpfr_dir"
4488   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4489 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4490 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4491 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4492    { (exit 1); exit 1; }; }
4493 fi;
4494
4495
4496 # Check whether --with-mpfr or --without-mpfr was given.
4497 if test "${with_mpfr+set}" = set; then
4498   withval="$with_mpfr"
4499
4500 fi;
4501
4502 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4503 if test "${with_mpfr_include+set}" = set; then
4504   withval="$with_mpfr_include"
4505
4506 fi;
4507
4508 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4509 if test "${with_mpfr_lib+set}" = set; then
4510   withval="$with_mpfr_lib"
4511
4512 fi;
4513
4514 if test "x$with_mpfr" != x; then
4515   gmplibs="-L$with_mpfr/lib $gmplibs"
4516   gmpinc="-I$with_mpfr/include"
4517 fi
4518 if test "x$with_mpfr_include" != x; then
4519   gmpinc="-I$with_mpfr_include"
4520 fi
4521 if test "x$with_mpfr_lib" != x; then
4522   gmplibs="-L$with_mpfr_lib $gmplibs"
4523 fi
4524 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4525   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4526   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4527   # Do not test the mpfr version.  Assume that it is sufficient, since
4528   # it is in the source tree, and the library has not been built yet
4529   # but it would be included on the link line in the version check below
4530   # hence making the test fail.
4531   have_gmp=yes
4532 fi
4533
4534 # Specify a location for gmp
4535
4536 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4537 if test "${with_gmp_dir+set}" = set; then
4538   withval="$with_gmp_dir"
4539   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4540 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4541 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4542 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4543    { (exit 1); exit 1; }; }
4544 fi;
4545
4546
4547 # Check whether --with-gmp or --without-gmp was given.
4548 if test "${with_gmp+set}" = set; then
4549   withval="$with_gmp"
4550
4551 fi;
4552
4553 # Check whether --with-gmp_include or --without-gmp_include was given.
4554 if test "${with_gmp_include+set}" = set; then
4555   withval="$with_gmp_include"
4556
4557 fi;
4558
4559 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4560 if test "${with_gmp_lib+set}" = set; then
4561   withval="$with_gmp_lib"
4562
4563 fi;
4564
4565
4566 if test "x$with_gmp" != x; then
4567   gmplibs="-L$with_gmp/lib $gmplibs"
4568   gmpinc="-I$with_gmp/include $gmpinc"
4569 fi
4570 if test "x$with_gmp_include" != x; then
4571   gmpinc="-I$with_gmp_include $gmpinc"
4572 fi
4573 if test "x$with_gmp_lib" != x; then
4574   gmplibs="-L$with_gmp_lib $gmplibs"
4575 fi
4576 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4577   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4578   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4579   # Do not test the gmp version.  Assume that it is sufficient, since
4580   # it is in the source tree, and the library has not been built yet
4581   # but it would be included on the link line in the version check below
4582   # hence making the test fail.
4583   have_gmp=yes
4584 fi
4585
4586 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4587   have_gmp=yes
4588   saved_CFLAGS="$CFLAGS"
4589   CFLAGS="$CFLAGS $gmpinc"
4590   # Check GMP actually works
4591   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4592 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4593
4594 cat >conftest.$ac_ext <<_ACEOF
4595 /* confdefs.h.  */
4596 _ACEOF
4597 cat confdefs.h >>conftest.$ac_ext
4598 cat >>conftest.$ac_ext <<_ACEOF
4599 /* end confdefs.h.  */
4600 #include "gmp.h"
4601 int
4602 main ()
4603 {
4604
4605   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4606   choke me
4607   #endif
4608
4609   ;
4610   return 0;
4611 }
4612 _ACEOF
4613 rm -f conftest.$ac_objext
4614 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4615   (eval $ac_compile) 2>conftest.er1
4616   ac_status=$?
4617   grep -v '^ *+' conftest.er1 >conftest.err
4618   rm -f conftest.er1
4619   cat conftest.err >&5
4620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4621   (exit $ac_status); } &&
4622          { ac_try='test -z "$ac_c_werror_flag"
4623                          || test ! -s conftest.err'
4624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4625   (eval $ac_try) 2>&5
4626   ac_status=$?
4627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4628   (exit $ac_status); }; } &&
4629          { ac_try='test -s conftest.$ac_objext'
4630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4631   (eval $ac_try) 2>&5
4632   ac_status=$?
4633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4634   (exit $ac_status); }; }; then
4635   echo "$as_me:$LINENO: result: yes" >&5
4636 echo "${ECHO_T}yes" >&6
4637 else
4638   echo "$as_me: failed program was:" >&5
4639 sed 's/^/| /' conftest.$ac_ext >&5
4640
4641 echo "$as_me:$LINENO: result: no" >&5
4642 echo "${ECHO_T}no" >&6; have_gmp=no
4643 fi
4644 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4645
4646   if test x"$have_gmp" = xyes; then
4647     saved_LIBS="$LIBS"
4648     LIBS="$LIBS $gmplibs"
4649         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4650 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4651     cat >conftest.$ac_ext <<_ACEOF
4652 /* confdefs.h.  */
4653 _ACEOF
4654 cat confdefs.h >>conftest.$ac_ext
4655 cat >>conftest.$ac_ext <<_ACEOF
4656 /* end confdefs.h.  */
4657 #include <gmp.h>
4658     #include <mpfr.h>
4659 int
4660 main ()
4661 {
4662
4663     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4664     choke me
4665     #endif
4666     mpfr_t n;
4667     mpfr_t x;
4668     int t;
4669     mpfr_init (n);
4670     mpfr_init (x);
4671     mpfr_atan2 (n, n, x, GMP_RNDN);
4672     mpfr_erfc (n, x, GMP_RNDN);
4673     mpfr_subnormalize (x, t, GMP_RNDN);
4674
4675   ;
4676   return 0;
4677 }
4678 _ACEOF
4679 rm -f conftest.$ac_objext conftest$ac_exeext
4680 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4681   (eval $ac_link) 2>conftest.er1
4682   ac_status=$?
4683   grep -v '^ *+' conftest.er1 >conftest.err
4684   rm -f conftest.er1
4685   cat conftest.err >&5
4686   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4687   (exit $ac_status); } &&
4688          { ac_try='test -z "$ac_c_werror_flag"
4689                          || test ! -s conftest.err'
4690   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4691   (eval $ac_try) 2>&5
4692   ac_status=$?
4693   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4694   (exit $ac_status); }; } &&
4695          { ac_try='test -s conftest$ac_exeext'
4696   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4697   (eval $ac_try) 2>&5
4698   ac_status=$?
4699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4700   (exit $ac_status); }; }; then
4701   cat >conftest.$ac_ext <<_ACEOF
4702 /* confdefs.h.  */
4703 _ACEOF
4704 cat confdefs.h >>conftest.$ac_ext
4705 cat >>conftest.$ac_ext <<_ACEOF
4706 /* end confdefs.h.  */
4707 #include <gmp.h>
4708     #include <mpfr.h>
4709 int
4710 main ()
4711 {
4712
4713     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4714     choke me
4715     #endif
4716     mpfr_t n; mpfr_init(n);
4717
4718   ;
4719   return 0;
4720 }
4721 _ACEOF
4722 rm -f conftest.$ac_objext conftest$ac_exeext
4723 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4724   (eval $ac_link) 2>conftest.er1
4725   ac_status=$?
4726   grep -v '^ *+' conftest.er1 >conftest.err
4727   rm -f conftest.er1
4728   cat conftest.err >&5
4729   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4730   (exit $ac_status); } &&
4731          { ac_try='test -z "$ac_c_werror_flag"
4732                          || test ! -s conftest.err'
4733   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4734   (eval $ac_try) 2>&5
4735   ac_status=$?
4736   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4737   (exit $ac_status); }; } &&
4738          { ac_try='test -s conftest$ac_exeext'
4739   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4740   (eval $ac_try) 2>&5
4741   ac_status=$?
4742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4743   (exit $ac_status); }; }; then
4744   echo "$as_me:$LINENO: result: yes" >&5
4745 echo "${ECHO_T}yes" >&6
4746 else
4747   echo "$as_me: failed program was:" >&5
4748 sed 's/^/| /' conftest.$ac_ext >&5
4749
4750 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4751 echo "${ECHO_T}buggy but acceptable" >&6
4752 fi
4753 rm -f conftest.err conftest.$ac_objext \
4754       conftest$ac_exeext conftest.$ac_ext
4755 else
4756   echo "$as_me: failed program was:" >&5
4757 sed 's/^/| /' conftest.$ac_ext >&5
4758
4759 echo "$as_me:$LINENO: result: no" >&5
4760 echo "${ECHO_T}no" >&6; have_gmp=no
4761 fi
4762 rm -f conftest.err conftest.$ac_objext \
4763       conftest$ac_exeext conftest.$ac_ext
4764       LIBS="$saved_LIBS"
4765   fi
4766   CFLAGS="$saved_CFLAGS"
4767
4768   if test x$have_gmp != xyes; then
4769     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4770 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4771 Copies of these libraries' source code can be found at their respective
4772 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4773 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4774 If you obtained GMP and/or MPFR from a vendor distribution package, make
4775 sure that you have installed both the libraries and the header files.
4776 They may be located in separate packages." >&5
4777 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4778 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4779 Copies of these libraries' source code can be found at their respective
4780 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4781 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4782 If you obtained GMP and/or MPFR from a vendor distribution package, make
4783 sure that you have installed both the libraries and the header files.
4784 They may be located in separate packages." >&2;}
4785    { (exit 1); exit 1; }; }
4786   fi
4787 fi
4788
4789 # Flags needed for both GMP and/or MPFR
4790
4791
4792
4793 # By default, C is the only stage 1 language.
4794 stage1_languages=,c,
4795
4796 # Figure out what language subdirectories are present.
4797 # Look if the user specified --enable-languages="..."; if not, use
4798 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4799 # go away some day.
4800 # NB:  embedded tabs in this IF block -- do not untabify
4801 if test -d ${srcdir}/gcc; then
4802   if test x"${enable_languages+set}" != xset; then
4803     if test x"${LANGUAGES+set}" = xset; then
4804       enable_languages="${LANGUAGES}"
4805         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4806     else
4807       enable_languages=all
4808     fi
4809   else
4810     if test x"${enable_languages}" = x ||
4811        test x"${enable_languages}" = xyes;
4812        then
4813       echo configure.in: --enable-languages needs at least one language argument 1>&2
4814       exit 1
4815     fi
4816   fi
4817   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4818
4819   # 'f95' is the old name for the 'fortran' language. We issue a warning
4820   # and make the substitution.
4821   case ,${enable_languages}, in
4822     *,f95,*)
4823       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4824       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4825       ;;
4826   esac
4827
4828   # First scan to see if an enabled language requires some other language.
4829   # We assume that a given config-lang.in will list all the language
4830   # front ends it requires, even if some are required indirectly.
4831   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4832     case ${lang_frag} in
4833       ..) ;;
4834       # The odd quoting in the next line works around
4835       # an apparent bug in bash 1.12 on linux.
4836       ${srcdir}/gcc/[*]/config-lang.in) ;;
4837       *)
4838         # From the config-lang.in, get $language, $lang_requires
4839         language=
4840         lang_requires=
4841         . ${lang_frag}
4842         for other in ${lang_requires} ; do
4843           case ,${enable_languages}, in
4844             *,$other,*) ;;
4845             *,all,*) ;;
4846             *,$language,*)
4847               echo " \`$other' language required by \`$language'; enabling" 1>&2
4848               enable_languages="${enable_languages},${other}"
4849               ;;
4850           esac
4851         done
4852         ;;
4853     esac
4854   done
4855
4856   new_enable_languages=,c,
4857   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4858   potential_languages=,c,
4859
4860   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4861     case ${lang_frag} in
4862       ..) ;;
4863       # The odd quoting in the next line works around
4864       # an apparent bug in bash 1.12 on linux.
4865       ${srcdir}/gcc/[*]/config-lang.in) ;;
4866       *)
4867         # From the config-lang.in, get $language, $target_libs,
4868         # $lang_dirs, $boot_language, and $build_by_default
4869         language=
4870         target_libs=
4871         lang_dirs=
4872         subdir_requires=
4873         boot_language=no
4874         build_by_default=yes
4875         . ${lang_frag}
4876         if test x${language} = x; then
4877           echo "${lang_frag} doesn't set \$language." 1>&2
4878           exit 1
4879         fi
4880
4881         case ,${enable_languages}, in
4882           *,${language},*)
4883             # Language was explicitly selected; include it.
4884             add_this_lang=yes
4885             ;;
4886           *,all,*)
4887             # 'all' was selected, select it if it is a default language
4888             add_this_lang=${build_by_default}
4889             ;;
4890           *)
4891             add_this_lang=no
4892             ;;
4893         esac
4894
4895         # Disable languages that need other directories if these aren't available.
4896         for i in $subdir_requires; do
4897           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4898           case ,${enable_languages}, in
4899             *,${language},*)
4900               # Specifically requested language; tell them.
4901               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4902 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4903    { (exit 1); exit 1; }; }
4904               ;;
4905             *)
4906               # Silently disable.
4907               add_this_lang=unsupported
4908               ;;
4909           esac
4910         done
4911
4912         # Disable Ada if no preexisting GNAT is available.
4913         case ,${enable_languages},:${language}:${have_gnat} in
4914           *,${language},*:ada:no)
4915             # Specifically requested language; tell them.
4916             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4917 echo "$as_me: error: GNAT is required to build $language" >&2;}
4918    { (exit 1); exit 1; }; }
4919             ;;
4920           *:ada:no)
4921             # Silently disable.
4922             add_this_lang=unsupported
4923             ;;
4924         esac
4925
4926         # Disable a language that is unsupported by the target.
4927         case " $unsupported_languages " in
4928           *" $language "*)
4929             add_this_lang=unsupported
4930             ;;
4931         esac
4932
4933         case $add_this_lang in
4934           unsupported)
4935             # Remove language-dependent dirs.
4936             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4937             ;;
4938           no)
4939             # Remove language-dependent dirs; still show language as supported.
4940             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4941             potential_languages="${potential_languages}${language},"
4942             ;;
4943           yes)
4944             new_enable_languages="${new_enable_languages}${language},"
4945             potential_languages="${potential_languages}${language},"
4946             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4947             case ${boot_language} in
4948               yes)
4949                 # Add to (comma-separated) list of stage 1 languages.
4950                 stage1_languages="${stage1_languages}${language},"
4951                 ;;
4952             esac
4953             ;;
4954         esac
4955         ;;
4956     esac
4957   done
4958
4959   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4960 if test "${enable_stage1_languages+set}" = set; then
4961   enableval="$enable_stage1_languages"
4962   case ,${enable_stage1_languages}, in
4963     ,no,|,,)
4964       # Set it to something that will have no effect in the loop below
4965       enable_stage1_languages=c ;;
4966     ,yes,)
4967       enable_stage1_languages=`echo $new_enable_languages | \
4968         sed -e "s/^,//" -e "s/,$//" ` ;;
4969     *,all,*)
4970       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4971         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4972   esac
4973
4974   # Add "good" languages from enable_stage1_languages to stage1_languages,
4975   # while "bad" languages go in missing_languages.  Leave no duplicates.
4976   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4977     case $potential_languages in
4978       *,$i,*)
4979         case $stage1_languages in
4980           *,$i,*) ;;
4981           *) stage1_languages="$stage1_languages$i," ;;
4982         esac ;;
4983       *)
4984         case $missing_languages in
4985           *,$i,*) ;;
4986           *) missing_languages="$missing_languages$i," ;;
4987         esac ;;
4988      esac
4989   done
4990 fi;
4991
4992   # Remove leading/trailing commas that were added for simplicity
4993   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4994   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4995   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4996   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4997
4998   if test "x$missing_languages" != x; then
4999     { { echo "$as_me:$LINENO: error:
5000 The following requested languages could not be built: ${missing_languages}
5001 Supported languages are: ${potential_languages}" >&5
5002 echo "$as_me: error:
5003 The following requested languages could not be built: ${missing_languages}
5004 Supported languages are: ${potential_languages}" >&2;}
5005    { (exit 1); exit 1; }; }
5006   fi
5007   if test "x$new_enable_languages" != "x$enable_languages"; then
5008     echo The following languages will be built: ${new_enable_languages}
5009     enable_languages="$new_enable_languages"
5010   fi
5011
5012
5013   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5014 fi
5015
5016 # Handle --disable-<component> generically.
5017 for dir in $configdirs $build_configdirs $target_configdirs ; do
5018   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5019   varname=`echo $dirname | sed -e s/+/_/g`
5020   if eval test x\${enable_${varname}} "=" xno ; then
5021     noconfigdirs="$noconfigdirs $dir"
5022   fi
5023 done
5024
5025 # Check for Boehm's garbage collector
5026 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5027 if test "${enable_objc_gc+set}" = set; then
5028   enableval="$enable_objc_gc"
5029   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5030   *,objc,*:*:yes:*target-boehm-gc*)
5031     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5032 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5033    { (exit 1); exit 1; }; }
5034     ;;
5035 esac
5036 fi;
5037
5038 # Make sure we only build Boehm's garbage collector if required.
5039 case ,${enable_languages},:${enable_objc_gc} in
5040   *,objc,*:yes)
5041     # Keep target-boehm-gc if requested for Objective-C.
5042     ;;
5043   *)
5044     # Otherwise remove target-boehm-gc depending on target-libjava.
5045     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5046       noconfigdirs="$noconfigdirs target-boehm-gc"
5047     fi
5048     ;;
5049 esac
5050
5051 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5052 # $build_configdirs and $target_configdirs.
5053 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5054
5055 notsupp=""
5056 for dir in . $skipdirs $noconfigdirs ; do
5057   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5058   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5059     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5060     if test -r $srcdir/$dirname/configure ; then
5061       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5062         true
5063       else
5064         notsupp="$notsupp $dir"
5065       fi
5066     fi
5067   fi
5068   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5069     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5070     if test -r $srcdir/$dirname/configure ; then
5071       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5072         true
5073       else
5074         notsupp="$notsupp $dir"
5075       fi
5076     fi
5077   fi
5078   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5079     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5080     if test -r $srcdir/$dirname/configure ; then
5081       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5082         true
5083       else
5084         notsupp="$notsupp $dir"
5085       fi
5086     fi
5087   fi
5088 done
5089
5090 # Sometimes the tools are distributed with libiberty but with no other
5091 # libraries.  In that case, we don't want to build target-libiberty.
5092 # Don't let libgcc imply libiberty either.
5093 if test -n "${target_configdirs}" ; then
5094   libgcc=
5095   others=
5096   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5097     if test "$i" = "libgcc"; then
5098       libgcc=target-libgcc
5099     elif test "$i" != "libiberty" ; then
5100       if test -r $srcdir/$i/configure ; then
5101         others=yes;
5102         break;
5103       fi
5104     fi
5105   done
5106   if test -z "${others}" ; then
5107     target_configdirs=$libgcc
5108   fi
5109 fi
5110
5111 # Quietly strip out all directories which aren't configurable in this tree.
5112 # This relies on all configurable subdirectories being autoconfiscated, which
5113 # is now the case.
5114 build_configdirs_all="$build_configdirs"
5115 build_configdirs=
5116 for i in ${build_configdirs_all} ; do
5117   j=`echo $i | sed -e s/build-//g`
5118   if test -f ${srcdir}/$j/configure ; then
5119     build_configdirs="${build_configdirs} $i"
5120   fi
5121 done
5122
5123 configdirs_all="$configdirs"
5124 configdirs=
5125 for i in ${configdirs_all} ; do
5126   if test -f ${srcdir}/$i/configure ; then
5127     configdirs="${configdirs} $i"
5128   fi
5129 done
5130
5131 target_configdirs_all="$target_configdirs"
5132 target_configdirs=
5133 for i in ${target_configdirs_all} ; do
5134   j=`echo $i | sed -e s/target-//g`
5135   if test -f ${srcdir}/$j/configure ; then
5136     target_configdirs="${target_configdirs} $i"
5137   fi
5138 done
5139
5140 # Produce a warning message for the subdirs we can't configure.
5141 # This isn't especially interesting in the Cygnus tree, but in the individual
5142 # FSF releases, it's important to let people know when their machine isn't
5143 # supported by the one or two programs in a package.
5144
5145 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5146   # If $appdirs is non-empty, at least one of those directories must still
5147   # be configured, or we error out.  (E.g., if the gas release supports a
5148   # specified target in some subdirs but not the gas subdir, we shouldn't
5149   # pretend that all is well.)
5150   if test -n "$appdirs" ; then
5151     for dir in $appdirs ; do
5152       if test -r $dir/Makefile.in ; then
5153         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5154           appdirs=""
5155           break
5156         fi
5157         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5158           appdirs=""
5159           break
5160         fi
5161       fi
5162     done
5163     if test -n "$appdirs" ; then
5164       echo "*** This configuration is not supported by this package." 1>&2
5165       exit 1
5166     fi
5167   fi
5168   # Okay, some application will build, or we don't care to check.  Still
5169   # notify of subdirs not getting built.
5170   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5171   echo "    ${notsupp}" 1>&2
5172   echo "    (Any other directories should still work fine.)" 1>&2
5173 fi
5174
5175 case "$host" in
5176   *msdosdjgpp*)
5177     enable_gdbtk=no ;;
5178 esac
5179
5180 # To find our prefix, in gcc_cv_tool_prefix.
5181
5182 # The user is always right.
5183 if test "${PATH_SEPARATOR+set}" != set; then
5184   echo "#! /bin/sh" >conf$$.sh
5185   echo  "exit 0"   >>conf$$.sh
5186   chmod +x conf$$.sh
5187   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5188     PATH_SEPARATOR=';'
5189   else
5190     PATH_SEPARATOR=:
5191   fi
5192   rm -f conf$$.sh
5193 fi
5194
5195
5196
5197 if test "x$exec_prefix" = xNONE; then
5198         if test "x$prefix" = xNONE; then
5199                 gcc_cv_tool_prefix=$ac_default_prefix
5200         else
5201                 gcc_cv_tool_prefix=$prefix
5202         fi
5203 else
5204         gcc_cv_tool_prefix=$exec_prefix
5205 fi
5206
5207 # If there is no compiler in the tree, use the PATH only.  In any
5208 # case, if there is no compiler in the tree nobody should use
5209 # AS_FOR_TARGET and LD_FOR_TARGET.
5210 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5211     gcc_version=`cat $srcdir/gcc/BASE-VER`
5212     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5213     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5214     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5215     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5216     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5217     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5218 else
5219     gcc_cv_tool_dirs=
5220 fi
5221
5222 if test x$build = x$target && test -n "$md_exec_prefix"; then
5223         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5224 fi
5225
5226
5227
5228 copy_dirs=
5229
5230
5231 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5232 if test "${with_build_sysroot+set}" = set; then
5233   withval="$with_build_sysroot"
5234   if test x"$withval" != x ; then
5235      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5236    fi
5237 else
5238   SYSROOT_CFLAGS_FOR_TARGET=
5239 fi;
5240
5241
5242
5243 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5244 if test "${with_debug_prefix_map+set}" = set; then
5245   withval="$with_debug_prefix_map"
5246   if test x"$withval" != x; then
5247      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5248      for debug_map in $withval; do
5249        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5250      done
5251    fi
5252 else
5253   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5254 fi;
5255
5256
5257 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5258 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5259 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5260 # We want to ensure that TARGET libraries (which we know are built with
5261 # gcc) are built with "-O2 -g", so include those options when setting
5262 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5263 if test "x$CFLAGS_FOR_TARGET" = x; then
5264   CFLAGS_FOR_TARGET=$CFLAGS
5265   case " $CFLAGS " in
5266     *" -O2 "*) ;;
5267     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5268   esac
5269   case " $CFLAGS " in
5270     *" -g "* | *" -g3 "*) ;;
5271     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5272   esac
5273 fi
5274
5275
5276 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5277   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5278   case " $CXXFLAGS " in
5279     *" -O2 "*) ;;
5280     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5281   esac
5282   case " $CXXFLAGS " in
5283     *" -g "* | *" -g3 "*) ;;
5284     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5285   esac
5286 fi
5287
5288
5289 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5290 # the named directory are copied to $(tooldir)/sys-include.
5291 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5292   if test x${is_cross_compiler} = xno ; then
5293     echo 1>&2 '***' --with-headers is only supported when cross compiling
5294     exit 1
5295   fi
5296   if test x"${with_headers}" != xyes ; then
5297     x=${gcc_cv_tool_prefix}
5298     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5299   fi
5300 fi
5301
5302 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5303 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5304 # are permitted.
5305 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5306   if test x${is_cross_compiler} = xno ; then
5307     echo 1>&2 '***' --with-libs is only supported when cross compiling
5308     exit 1
5309   fi
5310   if test x"${with_libs}" != xyes ; then
5311     # Copy the libraries in reverse order, so that files in the first named
5312     # library override files in subsequent libraries.
5313     x=${gcc_cv_tool_prefix}
5314     for l in ${with_libs}; do
5315       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5316     done
5317   fi
5318 fi
5319
5320 # Set with_gnu_as and with_gnu_ld as appropriate.
5321 #
5322 # This is done by determining whether or not the appropriate directory
5323 # is available, and by checking whether or not specific configurations
5324 # have requested that this magic not happen.
5325 #
5326 # The command line options always override the explicit settings in
5327 # configure.in, and the settings in configure.in override this magic.
5328 #
5329 # If the default for a toolchain is to use GNU as and ld, and you don't
5330 # want to do that, then you should use the --without-gnu-as and
5331 # --without-gnu-ld options for the configure script.
5332
5333 if test x${use_gnu_as} = x &&
5334    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5335   with_gnu_as=yes
5336   extra_host_args="$extra_host_args --with-gnu-as"
5337 fi
5338
5339 if test x${use_gnu_ld} = x &&
5340    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5341   with_gnu_ld=yes
5342   extra_host_args="$extra_host_args --with-gnu-ld"
5343 fi
5344
5345 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5346 # can detect this case.
5347
5348 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5349   with_newlib=yes
5350   extra_host_args="$extra_host_args --with-newlib"
5351 fi
5352
5353 # Handle ${copy_dirs}
5354 set fnord ${copy_dirs}
5355 shift
5356 while test $# != 0 ; do
5357   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5358     :
5359   else
5360     echo Copying $1 to $2
5361
5362     # Use the install script to create the directory and all required
5363     # parent directories.
5364     if test -d $2 ; then
5365       :
5366     else
5367       echo >config.temp
5368       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5369     fi
5370
5371     # Copy the directory, assuming we have tar.
5372     # FIXME: Should we use B in the second tar?  Not all systems support it.
5373     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5374
5375     # It is the responsibility of the user to correctly adjust all
5376     # symlinks.  If somebody can figure out how to handle them correctly
5377     # here, feel free to add the code.
5378
5379     echo $1 > $2/COPIED
5380   fi
5381   shift; shift
5382 done
5383
5384 # Determine a target-dependent exec_prefix that the installed
5385 # gcc will search in.  Keep this list sorted by triplet, with
5386 # the *-*-osname triplets last.
5387 md_exec_prefix=
5388 case "${target}" in
5389   alpha*-*-*vms*)
5390     md_exec_prefix=/gnu/lib/gcc-lib
5391     ;;
5392   i[34567]86-pc-msdosdjgpp*)
5393     md_exec_prefix=/dev/env/DJDIR/bin
5394     ;;
5395   i[34567]86-*-sco3.2v5*)
5396     if test $with_gnu_as = yes; then
5397       md_exec_prefix=/usr/gnu/bin
5398     else
5399       md_exec_prefix=/usr/ccs/bin/elf
5400     fi
5401     ;;
5402
5403   mn10300-*-* | \
5404   powerpc-*-chorusos* | \
5405   powerpc*-*-eabi* | \
5406   powerpc*-*-sysv* | \
5407   powerpc*-*-kaos* | \
5408   s390x-ibm-tpf*)
5409     md_exec_prefix=/usr/ccs/bin
5410     ;;
5411   sparc64-*-elf*)
5412     ;;
5413   v850*-*-*)
5414     md_exec_prefix=/usr/ccs/bin
5415     ;;
5416   xtensa*-*-elf*)
5417     ;;
5418
5419   *-*-beos* | \
5420   *-*-elf* | \
5421   *-*-hpux* | \
5422   *-*-netware* | \
5423   *-*-nto-qnx* | \
5424   *-*-rtems* | \
5425   *-*-solaris2* | \
5426   *-*-sysv[45]* | \
5427   *-*-vxworks* | \
5428   *-wrs-windiss)
5429     md_exec_prefix=/usr/ccs/bin
5430     ;;
5431 esac
5432
5433 extra_arflags_for_target=
5434 extra_nmflags_for_target=
5435 extra_ranlibflags_for_target=
5436 target_makefile_frag=/dev/null
5437 case "${target}" in
5438   mep*-*-*)
5439     target_makefile_frag="config/mt-mep"
5440     ;;
5441   spu-*-*)
5442     target_makefile_frag="config/mt-spu"
5443     ;;
5444   mips*-sde-elf*)
5445     target_makefile_frag="config/mt-sde"
5446     ;;
5447   mipsisa*-*-elfoabi*)
5448     target_makefile_frag="config/mt-mips-elfoabi"
5449     ;;
5450   mips*-*-*linux* | mips*-*-gnu*)
5451     target_makefile_frag="config/mt-mips-gnu"
5452     ;;
5453   *-*-netware*)
5454     target_makefile_frag="config/mt-netware"
5455     ;;
5456   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5457     target_makefile_frag="config/mt-gnu"
5458     ;;
5459   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5460     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5461     # commands to handle both 32-bit and 64-bit objects.  These flags are
5462     # harmless if we're using GNU nm or ar.
5463     extra_arflags_for_target=" -X32_64"
5464     extra_nmflags_for_target=" -B -X32_64"
5465     ;;
5466   *-*-darwin*)
5467     # ranlib from Darwin requires the -c flag to look at common symbols.
5468     extra_ranlibflags_for_target=" -c"
5469     ;;
5470   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5471     target_makefile_frag="config/mt-wince"
5472     ;;
5473 esac
5474
5475 alphaieee_frag=/dev/null
5476 case $target in
5477   alpha*-*-*)
5478     # This just makes sure to use the -mieee option to build target libs.
5479     # This should probably be set individually by each library.
5480     alphaieee_frag="config/mt-alphaieee"
5481     ;;
5482 esac
5483
5484 # If --enable-target-optspace always use -Os instead of -O2 to build
5485 # the target libraries, similarly if it is not specified, use -Os
5486 # on selected platforms.
5487 ospace_frag=/dev/null
5488 case "${enable_target_optspace}:${target}" in
5489   yes:*)
5490     ospace_frag="config/mt-ospace"
5491     ;;
5492   :d30v-*)
5493     ospace_frag="config/mt-d30v"
5494     ;;
5495   :m32r-* | :d10v-* | :fr30-*)
5496     ospace_frag="config/mt-ospace"
5497     ;;
5498   no:* | :*)
5499     ;;
5500   *)
5501     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5502     ;;
5503 esac
5504
5505 # Default to using --with-stabs for certain targets.
5506 if test x${with_stabs} = x ; then
5507   case "${target}" in
5508   mips*-*-irix[56]*)
5509     ;;
5510   mips*-*-* | alpha*-*-osf*)
5511     with_stabs=yes;
5512     extra_host_args="${extra_host_args} --with-stabs"
5513     ;;
5514   esac
5515 fi
5516
5517 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5518 # them automatically.
5519 case "${host}" in
5520   hppa*64*-*-hpux11*)
5521     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5522     ;;
5523 esac
5524
5525 # Some systems (e.g., one of the i386-aix systems the gas testers are
5526 # using) don't handle "\$" correctly, so don't use it here.
5527 tooldir='${exec_prefix}'/${target_noncanonical}
5528 build_tooldir=${tooldir}
5529
5530 # Create a .gdbinit file which runs the one in srcdir
5531 # and tells GDB to look there for source files.
5532
5533 if test -r ${srcdir}/.gdbinit ; then
5534   case ${srcdir} in
5535     .) ;;
5536     *) cat > ./.gdbinit <<EOF
5537 # ${NO_EDIT}
5538 dir ${srcdir}
5539 dir .
5540 source ${srcdir}/.gdbinit
5541 EOF
5542     ;;
5543   esac
5544 fi
5545
5546 # Make sure that the compiler is able to generate an executable.  If it
5547 # can't, we are probably in trouble.  We don't care whether we can run the
5548 # executable--we might be using a cross compiler--we only care whether it
5549 # can be created.  At this point the main configure script has set CC.
5550 we_are_ok=no
5551 echo "int main () { return 0; }" > conftest.c
5552 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5553 if test $? = 0 ; then
5554   if test -s conftest || test -s conftest.exe ; then
5555     we_are_ok=yes
5556   fi
5557 fi
5558 case $we_are_ok in
5559   no)
5560     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5561     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5562     rm -f conftest*
5563     exit 1
5564     ;;
5565 esac
5566 rm -f conftest*
5567
5568 # The Solaris /usr/ucb/cc compiler does not appear to work.
5569 case "${host}" in
5570   sparc-sun-solaris2*)
5571       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5572       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5573           could_use=
5574           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5575           if test -d /opt/cygnus/bin ; then
5576               if test "$could_use" = "" ; then
5577                   could_use="/opt/cygnus/bin"
5578               else
5579                   could_use="$could_use or /opt/cygnus/bin"
5580               fi
5581           fi
5582         if test "$could_use" = "" ; then
5583             echo "Warning: compilation may fail because you're using"
5584             echo "/usr/ucb/cc.  You should change your PATH or CC "
5585             echo "variable and rerun configure."
5586         else
5587             echo "Warning: compilation may fail because you're using"
5588             echo "/usr/ucb/cc, when you should use the C compiler from"
5589             echo "$could_use.  You should change your"
5590             echo "PATH or CC variable and rerun configure."
5591         fi
5592       fi
5593   ;;
5594 esac
5595
5596 # Decide which environment variable is used to find dynamic libraries.
5597 case "${host}" in
5598   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5599   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5600   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5601   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5602 esac
5603
5604 # On systems where the dynamic library environment variable is PATH,
5605 if test "$RPATH_ENVVAR" = PATH; then
5606   GCC_SHLIB_SUBDIR=/shlib
5607 else
5608   GCC_SHLIB_SUBDIR=
5609 fi
5610
5611 # Record target_configdirs and the configure arguments for target and
5612 # build configuration in Makefile.
5613 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5614 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5615
5616 # Determine whether gdb needs tk/tcl or not.
5617 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5618 # and in that case we want gdb to be built without tk.  Ugh!
5619 # In fact I believe gdb is the *only* package directly dependent on tk,
5620 # so we should be able to put the 'maybe's in unconditionally and
5621 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5622 # 100% sure that that's safe though.
5623
5624 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5625 case "$enable_gdbtk" in
5626   no)
5627     GDB_TK="" ;;
5628   yes)
5629     GDB_TK="${gdb_tk}" ;;
5630   *)
5631     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5632     # distro.  Eventually someone will fix this and move Insight, nee
5633     # gdbtk to a separate directory.
5634     if test -d ${srcdir}/gdb/gdbtk ; then
5635       GDB_TK="${gdb_tk}"
5636     else
5637       GDB_TK=""
5638     fi
5639     ;;
5640 esac
5641 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5642 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5643
5644 # Strip out unwanted targets.
5645
5646 # While at that, we remove Makefiles if we were started for recursive
5647 # configuration, so that the top-level Makefile reconfigures them,
5648 # like we used to do when configure itself was recursive.
5649
5650 # Loop over modules.  $extrasub must be used with care, limiting as
5651 # much as possible the usage of range addresses.  That's because autoconf
5652 # splits the sed script to overcome limits in the number of commands,
5653 # and relying on carefully-timed sed passes may turn out to be very hard
5654 # to maintain later.  In this particular case, you just have to be careful
5655 # not to nest @if/@endif pairs, because configure will not warn you at all.
5656
5657 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5658 if test "${enable_bootstrap+set}" = set; then
5659   enableval="$enable_bootstrap"
5660
5661 else
5662   enable_bootstrap=default
5663 fi;
5664
5665 # Issue errors and warnings for invalid/strange bootstrap combinations.
5666 case "$configdirs" in
5667   *gcc*) have_compiler=yes ;;
5668   *) have_compiler=no ;;
5669 esac
5670
5671 case "$have_compiler:$host:$target:$enable_bootstrap" in
5672   *:*:*:no) ;;
5673
5674   # Default behavior.  Enable bootstrap if we have a compiler
5675   # and we are in a native configuration.
5676   yes:$build:$build:default)
5677     enable_bootstrap=yes ;;
5678
5679   *:*:*:default)
5680     enable_bootstrap=no ;;
5681
5682   # We have a compiler and we are in a native configuration, bootstrap is ok
5683   yes:$build:$build:yes)
5684     ;;
5685
5686   # Other configurations, but we have a compiler.  Assume the user knows
5687   # what he's doing.
5688   yes:*:*:yes)
5689     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5690 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5691     ;;
5692
5693   # No compiler: if they passed --enable-bootstrap explicitly, fail
5694   no:*:*:yes)
5695     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5696 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5697    { (exit 1); exit 1; }; } ;;
5698
5699   # Fail if wrong command line
5700   *)
5701     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5702 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5703    { (exit 1); exit 1; }; }
5704     ;;
5705 esac
5706
5707 # Adjust the toplevel makefile according to whether bootstrap was selected.
5708 case "$enable_bootstrap" in
5709   yes)
5710     bootstrap_suffix=bootstrap ;;
5711   no)
5712     bootstrap_suffix=no-bootstrap ;;
5713 esac
5714
5715 for module in ${build_configdirs} ; do
5716   if test -z "${no_recursion}" \
5717      && test -f ${build_subdir}/${module}/Makefile; then
5718     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5719     rm -f ${build_subdir}/${module}/Makefile
5720   fi
5721   extrasub="$extrasub
5722 /^@if build-$module\$/d
5723 /^@endif build-$module\$/d
5724 /^@if build-$module-$bootstrap_suffix\$/d
5725 /^@endif build-$module-$bootstrap_suffix\$/d"
5726 done
5727 for module in ${configdirs} ; do
5728   if test -z "${no_recursion}"; then
5729     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5730       if test -f ${file}; then
5731         echo 1>&2 "*** removing ${file} to force reconfigure"
5732         rm -f ${file}
5733       fi
5734     done
5735   fi
5736   extrasub="$extrasub
5737 /^@if $module\$/d
5738 /^@endif $module\$/d
5739 /^@if $module-$bootstrap_suffix\$/d
5740 /^@endif $module-$bootstrap_suffix\$/d"
5741 done
5742 for module in ${target_configdirs} ; do
5743   if test -z "${no_recursion}" \
5744      && test -f ${target_subdir}/${module}/Makefile; then
5745     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5746     rm -f ${target_subdir}/${module}/Makefile
5747   fi
5748   extrasub="$extrasub
5749 /^@if target-$module\$/d
5750 /^@endif target-$module\$/d
5751 /^@if target-$module-$bootstrap_suffix\$/d
5752 /^@endif target-$module-$bootstrap_suffix\$/d"
5753 done
5754
5755 extrasub="$extrasub
5756 /^@if /,/^@endif /d"
5757
5758 # Create the serialization dependencies.  This uses a temporary file.
5759
5760 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5761 if test "${enable_serial_configure+set}" = set; then
5762   enableval="$enable_serial_configure"
5763
5764 fi;
5765
5766 case ${enable_serial_configure} in
5767   yes)
5768     enable_serial_build_configure=yes
5769     enable_serial_host_configure=yes
5770     enable_serial_target_configure=yes
5771     ;;
5772 esac
5773
5774 # These force 'configure's to be done one at a time, to avoid problems
5775 # with contention over a shared config.cache.
5776 rm -f serdep.tmp
5777 echo '# serdep.tmp' > serdep.tmp
5778 olditem=
5779 test "x${enable_serial_build_configure}" = xyes &&
5780 for item in ${build_configdirs} ; do
5781   case ${olditem} in
5782     "") ;;
5783     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5784   esac
5785   olditem=${item}
5786 done
5787 olditem=
5788 test "x${enable_serial_host_configure}" = xyes &&
5789 for item in ${configdirs} ; do
5790   case ${olditem} in
5791     "") ;;
5792     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5793   esac
5794   olditem=${item}
5795 done
5796 olditem=
5797 test "x${enable_serial_target_configure}" = xyes &&
5798 for item in ${target_configdirs} ; do
5799   case ${olditem} in
5800     "") ;;
5801     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5802   esac
5803   olditem=${item}
5804 done
5805 serialization_dependencies=serdep.tmp
5806
5807
5808 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5809 # target, nonopt, and variable assignments.  These are the ones we
5810 # might not want to pass down to subconfigures.  Also strip
5811 # program-prefix, program-suffix, and program-transform-name, so that
5812 # we can pass down a consistent program-transform-name.
5813 baseargs=
5814 keep_next=no
5815 skip_next=no
5816 eval "set -- $ac_configure_args"
5817 for ac_arg
5818 do
5819   if test X"$skip_next" = X"yes"; then
5820     skip_next=no
5821     continue
5822   fi
5823   if test X"$keep_next" = X"yes"; then
5824     case $ac_arg in
5825       *\'*)
5826         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5827     esac
5828     baseargs="$baseargs '$ac_arg'"
5829     keep_next=no
5830     continue
5831   fi
5832
5833   # Handle separated arguments.  Based on the logic generated by
5834   # autoconf 2.59.
5835   case $ac_arg in
5836     *=* | --config-cache | -C | -disable-* | --disable-* \
5837       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5838       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5839       | -with-* | --with-* | -without-* | --without-* | --x)
5840       separate_arg=no
5841       ;;
5842     -*)
5843       separate_arg=yes
5844       ;;
5845     *)
5846       separate_arg=no
5847       ;;
5848   esac
5849
5850   case "$ac_arg" in
5851     --no*)
5852       continue
5853       ;;
5854     --c* | \
5855     --sr* | \
5856     --ho* | \
5857     --bu* | \
5858     --t* | \
5859     --program-* | \
5860     -cache_file* | \
5861     -srcdir* | \
5862     -host* | \
5863     -build* | \
5864     -target* | \
5865     -program-prefix* | \
5866     -program-suffix* | \
5867     -program-transform-name* )
5868       skip_next=$separate_arg
5869       continue
5870       ;;
5871     -*)
5872       # An option.  Add it.
5873       case $ac_arg in
5874         *\'*)
5875           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5876       esac
5877       baseargs="$baseargs '$ac_arg'"
5878       keep_next=$separate_arg
5879       ;;
5880     *)
5881       # Either a variable assignment, or a nonopt (triplet).  Don't
5882       # pass it down; let the Makefile handle this.
5883       continue
5884       ;;
5885   esac
5886 done
5887 # Remove the initial space we just introduced and, as these will be
5888 # expanded by make, quote '$'.
5889 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5890
5891 # Add in --program-transform-name, after --program-prefix and
5892 # --program-suffix have been applied to it.  Autoconf has already
5893 # doubled dollar signs and backslashes in program_transform_name; we want
5894 # the backslashes un-doubled, and then the entire thing wrapped in single
5895 # quotes, because this will be expanded first by make and then by the shell.
5896 # Also, because we want to override the logic in subdir configure scripts to
5897 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5898 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5899 ${program_transform_name}
5900 EOF_SED
5901 gcc_transform_name=`cat conftestsed.out`
5902 rm -f conftestsed.out
5903 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5904 if test "$silent" = yes; then
5905   baseargs="$baseargs --silent"
5906 fi
5907
5908 # For the build-side libraries, we just need to pretend we're native,
5909 # and not use the same cache file.  Multilibs are neither needed nor
5910 # desired.
5911 build_configargs="--cache-file=../config.cache ${baseargs}"
5912
5913 # For host modules, accept cache file option, or specification as blank.
5914 case "${cache_file}" in
5915 "") # empty
5916   cache_file_option="" ;;
5917 /* | [A-Za-z]:[\\/]* ) # absolute path
5918   cache_file_option="--cache-file=${cache_file}" ;;
5919 *) # relative path
5920   cache_file_option="--cache-file=../${cache_file}" ;;
5921 esac
5922
5923 # Host dirs don't like to share a cache file either, horribly enough.
5924 # This seems to be due to autoconf 2.5x stupidity.
5925 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5926
5927 target_configargs=${baseargs}
5928
5929 # Passing a --with-cross-host argument lets the target libraries know
5930 # whether they are being built with a cross-compiler or being built
5931 # native.  However, it would be better to use other mechanisms to make the
5932 # sorts of decisions they want to make on this basis.  Please consider
5933 # this option to be deprecated.  FIXME.
5934 if test x${is_cross_compiler} = xyes ; then
5935   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5936 fi
5937
5938 # Default to --enable-multilib.
5939 if test x${enable_multilib} = x ; then
5940   target_configargs="--enable-multilib ${target_configargs}"
5941 fi
5942
5943 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5944 # changed from the earlier setting of with_newlib.
5945 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5946   target_configargs="--with-newlib ${target_configargs}"
5947 fi
5948
5949 # Different target subdirs use different values of certain variables
5950 # (notably CXX).  Worse, multilibs use *lots* of different values.
5951 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5952 # it doesn't automatically accept command-line overrides of them.
5953 # This means it's not safe for target subdirs to share a cache file,
5954 # which is disgusting, but there you have it.  Hopefully this can be
5955 # fixed in future.  It's still worthwhile to use a cache file for each
5956 # directory.  I think.
5957
5958 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5959 # We need to pass --target, as newer autoconf's requires consistency
5960 # for target_alias and gcc doesn't manage it consistently.
5961 target_configargs="--cache-file=./config.cache ${target_configargs}"
5962
5963 FLAGS_FOR_TARGET=
5964 case " $target_configdirs " in
5965  *" newlib "*)
5966   case " $target_configargs " in
5967   *" --with-newlib "*)
5968    case "$target" in
5969    *-cygwin*)
5970      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' ;;
5971    esac
5972
5973    # If we're not building GCC, don't discard standard headers.
5974    if test -d ${srcdir}/gcc; then
5975      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5976
5977      if test "${build}" != "${host}"; then
5978        # On Canadian crosses, CC_FOR_TARGET will have already been set
5979        # by `configure', so we won't have an opportunity to add -Bgcc/
5980        # to it.  This is right: we don't want to search that directory
5981        # for binaries, but we want the header files in there, so add
5982        # them explicitly.
5983        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5984
5985        # Someone might think of using the pre-installed headers on
5986        # Canadian crosses, in case the installed compiler is not fully
5987        # compatible with the compiler being built.  In this case, it
5988        # would be better to flag an error than risking having
5989        # incompatible object files being constructed.  We can't
5990        # guarantee that an error will be flagged, but let's hope the
5991        # compiler will do it, when presented with incompatible header
5992        # files.
5993      fi
5994    fi
5995
5996    case "${target}-${is_cross_compiler}" in
5997    i[3456789]86-*-linux*-no)
5998       # Here host == target, so we don't need to build gcc,
5999       # so we don't want to discard standard headers.
6000       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6001       ;;
6002    *)
6003       # If we're building newlib, use its generic headers last, but search
6004       # for any libc-related directories first (so make it the last -B
6005       # switch).
6006       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6007
6008       # If we're building libgloss, find the startup file, simulator library
6009       # and linker script.
6010       case " $target_configdirs " in
6011         *" libgloss "*)
6012         # Look for startup file, simulator library and maybe linker script.
6013         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6014         # Look for libnosys.a in case the target needs it.
6015         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6016         # Most targets have the linker script in the source directory.
6017         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6018         ;;
6019       esac
6020       ;;
6021    esac
6022    ;;
6023   esac
6024   ;;
6025 esac
6026 case "$target" in
6027 *-mingw*)
6028   # Can't be handled as Cygwin above since Mingw does not use newlib.
6029   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' ;;
6030 esac
6031
6032 # Allow the user to override the flags for
6033 # our build compiler if desired.
6034 if test x"${build}" = x"${host}" ; then
6035   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6036   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6037   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6038 fi
6039
6040 # On Canadian crosses, we'll be searching the right directories for
6041 # the previously-installed cross compiler, so don't bother to add
6042 # flags for directories within the install tree of the compiler
6043 # being built; programs in there won't even run.
6044 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6045   # Search for pre-installed headers if nothing else fits.
6046   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6047 fi
6048
6049 if test "x${use_gnu_ld}" = x &&
6050    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6051   # Arrange for us to find uninstalled linker scripts.
6052   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6053 fi
6054
6055 # Search for other target-specific linker scripts and such.
6056 case "${target}" in
6057   mep*)
6058     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6059     ;;
6060 esac
6061
6062 # Makefile fragments.
6063 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6064 do
6065   eval fragval=\$$frag
6066   if test $fragval != /dev/null; then
6067     eval $frag=${srcdir}/$fragval
6068   fi
6069 done
6070
6071
6072
6073
6074
6075 # Miscellanea: directories, flags, etc.
6076
6077
6078
6079
6080
6081
6082
6083
6084 # Build module lists & subconfigure args.
6085
6086
6087
6088 # Host module lists & subconfigure args.
6089
6090
6091
6092 # Target module lists & subconfigure args.
6093
6094
6095
6096 # Build tools.
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114 # Generate default definitions for YACC, M4, LEX and other programs that run
6115 # on the build machine.  These are used if the Makefile can't locate these
6116 # programs in objdir.
6117 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6118
6119 for ac_prog in 'bison -y' byacc yacc
6120 do
6121   # Extract the first word of "$ac_prog", so it can be a program name with args.
6122 set dummy $ac_prog; ac_word=$2
6123 echo "$as_me:$LINENO: checking for $ac_word" >&5
6124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6125 if test "${ac_cv_prog_YACC+set}" = set; then
6126   echo $ECHO_N "(cached) $ECHO_C" >&6
6127 else
6128   if test -n "$YACC"; then
6129   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6130 else
6131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6132 for as_dir in $PATH
6133 do
6134   IFS=$as_save_IFS
6135   test -z "$as_dir" && as_dir=.
6136   for ac_exec_ext in '' $ac_executable_extensions; do
6137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6138     ac_cv_prog_YACC="$ac_prog"
6139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6140     break 2
6141   fi
6142 done
6143 done
6144
6145 fi
6146 fi
6147 YACC=$ac_cv_prog_YACC
6148 if test -n "$YACC"; then
6149   echo "$as_me:$LINENO: result: $YACC" >&5
6150 echo "${ECHO_T}$YACC" >&6
6151 else
6152   echo "$as_me:$LINENO: result: no" >&5
6153 echo "${ECHO_T}no" >&6
6154 fi
6155
6156   test -n "$YACC" && break
6157 done
6158 test -n "$YACC" || YACC="$MISSING bison -y"
6159
6160 case " $build_configdirs " in
6161   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6162   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6163 esac
6164
6165 for ac_prog in bison
6166 do
6167   # Extract the first word of "$ac_prog", so it can be a program name with args.
6168 set dummy $ac_prog; ac_word=$2
6169 echo "$as_me:$LINENO: checking for $ac_word" >&5
6170 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6171 if test "${ac_cv_prog_BISON+set}" = set; then
6172   echo $ECHO_N "(cached) $ECHO_C" >&6
6173 else
6174   if test -n "$BISON"; then
6175   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6176 else
6177 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6178 for as_dir in $PATH
6179 do
6180   IFS=$as_save_IFS
6181   test -z "$as_dir" && as_dir=.
6182   for ac_exec_ext in '' $ac_executable_extensions; do
6183   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6184     ac_cv_prog_BISON="$ac_prog"
6185     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6186     break 2
6187   fi
6188 done
6189 done
6190
6191 fi
6192 fi
6193 BISON=$ac_cv_prog_BISON
6194 if test -n "$BISON"; then
6195   echo "$as_me:$LINENO: result: $BISON" >&5
6196 echo "${ECHO_T}$BISON" >&6
6197 else
6198   echo "$as_me:$LINENO: result: no" >&5
6199 echo "${ECHO_T}no" >&6
6200 fi
6201
6202   test -n "$BISON" && break
6203 done
6204 test -n "$BISON" || BISON="$MISSING bison"
6205
6206 case " $build_configdirs " in
6207   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6208 esac
6209
6210 for ac_prog in gm4 gnum4 m4
6211 do
6212   # Extract the first word of "$ac_prog", so it can be a program name with args.
6213 set dummy $ac_prog; ac_word=$2
6214 echo "$as_me:$LINENO: checking for $ac_word" >&5
6215 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6216 if test "${ac_cv_prog_M4+set}" = set; then
6217   echo $ECHO_N "(cached) $ECHO_C" >&6
6218 else
6219   if test -n "$M4"; then
6220   ac_cv_prog_M4="$M4" # Let the user override the test.
6221 else
6222 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6223 for as_dir in $PATH
6224 do
6225   IFS=$as_save_IFS
6226   test -z "$as_dir" && as_dir=.
6227   for ac_exec_ext in '' $ac_executable_extensions; do
6228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6229     ac_cv_prog_M4="$ac_prog"
6230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6231     break 2
6232   fi
6233 done
6234 done
6235
6236 fi
6237 fi
6238 M4=$ac_cv_prog_M4
6239 if test -n "$M4"; then
6240   echo "$as_me:$LINENO: result: $M4" >&5
6241 echo "${ECHO_T}$M4" >&6
6242 else
6243   echo "$as_me:$LINENO: result: no" >&5
6244 echo "${ECHO_T}no" >&6
6245 fi
6246
6247   test -n "$M4" && break
6248 done
6249 test -n "$M4" || M4="$MISSING m4"
6250
6251 case " $build_configdirs " in
6252   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6253 esac
6254
6255 for ac_prog in flex lex
6256 do
6257   # Extract the first word of "$ac_prog", so it can be a program name with args.
6258 set dummy $ac_prog; ac_word=$2
6259 echo "$as_me:$LINENO: checking for $ac_word" >&5
6260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6261 if test "${ac_cv_prog_LEX+set}" = set; then
6262   echo $ECHO_N "(cached) $ECHO_C" >&6
6263 else
6264   if test -n "$LEX"; then
6265   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6266 else
6267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6268 for as_dir in $PATH
6269 do
6270   IFS=$as_save_IFS
6271   test -z "$as_dir" && as_dir=.
6272   for ac_exec_ext in '' $ac_executable_extensions; do
6273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6274     ac_cv_prog_LEX="$ac_prog"
6275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6276     break 2
6277   fi
6278 done
6279 done
6280
6281 fi
6282 fi
6283 LEX=$ac_cv_prog_LEX
6284 if test -n "$LEX"; then
6285   echo "$as_me:$LINENO: result: $LEX" >&5
6286 echo "${ECHO_T}$LEX" >&6
6287 else
6288   echo "$as_me:$LINENO: result: no" >&5
6289 echo "${ECHO_T}no" >&6
6290 fi
6291
6292   test -n "$LEX" && break
6293 done
6294 test -n "$LEX" || LEX="$MISSING flex"
6295
6296 case " $build_configdirs " in
6297   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6298   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6299 esac
6300
6301 for ac_prog in flex
6302 do
6303   # Extract the first word of "$ac_prog", so it can be a program name with args.
6304 set dummy $ac_prog; ac_word=$2
6305 echo "$as_me:$LINENO: checking for $ac_word" >&5
6306 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6307 if test "${ac_cv_prog_FLEX+set}" = set; then
6308   echo $ECHO_N "(cached) $ECHO_C" >&6
6309 else
6310   if test -n "$FLEX"; then
6311   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6312 else
6313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6314 for as_dir in $PATH
6315 do
6316   IFS=$as_save_IFS
6317   test -z "$as_dir" && as_dir=.
6318   for ac_exec_ext in '' $ac_executable_extensions; do
6319   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6320     ac_cv_prog_FLEX="$ac_prog"
6321     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6322     break 2
6323   fi
6324 done
6325 done
6326
6327 fi
6328 fi
6329 FLEX=$ac_cv_prog_FLEX
6330 if test -n "$FLEX"; then
6331   echo "$as_me:$LINENO: result: $FLEX" >&5
6332 echo "${ECHO_T}$FLEX" >&6
6333 else
6334   echo "$as_me:$LINENO: result: no" >&5
6335 echo "${ECHO_T}no" >&6
6336 fi
6337
6338   test -n "$FLEX" && break
6339 done
6340 test -n "$FLEX" || FLEX="$MISSING flex"
6341
6342 case " $build_configdirs " in
6343   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6344 esac
6345
6346 for ac_prog in makeinfo
6347 do
6348   # Extract the first word of "$ac_prog", so it can be a program name with args.
6349 set dummy $ac_prog; ac_word=$2
6350 echo "$as_me:$LINENO: checking for $ac_word" >&5
6351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6352 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6353   echo $ECHO_N "(cached) $ECHO_C" >&6
6354 else
6355   if test -n "$MAKEINFO"; then
6356   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6357 else
6358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6359 for as_dir in $PATH
6360 do
6361   IFS=$as_save_IFS
6362   test -z "$as_dir" && as_dir=.
6363   for ac_exec_ext in '' $ac_executable_extensions; do
6364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6365     ac_cv_prog_MAKEINFO="$ac_prog"
6366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6367     break 2
6368   fi
6369 done
6370 done
6371
6372 fi
6373 fi
6374 MAKEINFO=$ac_cv_prog_MAKEINFO
6375 if test -n "$MAKEINFO"; then
6376   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6377 echo "${ECHO_T}$MAKEINFO" >&6
6378 else
6379   echo "$as_me:$LINENO: result: no" >&5
6380 echo "${ECHO_T}no" >&6
6381 fi
6382
6383   test -n "$MAKEINFO" && break
6384 done
6385 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6386
6387 case " $build_configdirs " in
6388   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6389   *)
6390
6391     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6392     # higher, else we use the "missing" dummy.
6393     if ${MAKEINFO} --version \
6394        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6395       :
6396     else
6397       MAKEINFO="$MISSING makeinfo"
6398     fi
6399     ;;
6400
6401 esac
6402
6403 # FIXME: expect and dejagnu may become build tools?
6404
6405 for ac_prog in expect
6406 do
6407   # Extract the first word of "$ac_prog", so it can be a program name with args.
6408 set dummy $ac_prog; ac_word=$2
6409 echo "$as_me:$LINENO: checking for $ac_word" >&5
6410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6411 if test "${ac_cv_prog_EXPECT+set}" = set; then
6412   echo $ECHO_N "(cached) $ECHO_C" >&6
6413 else
6414   if test -n "$EXPECT"; then
6415   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6416 else
6417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6418 for as_dir in $PATH
6419 do
6420   IFS=$as_save_IFS
6421   test -z "$as_dir" && as_dir=.
6422   for ac_exec_ext in '' $ac_executable_extensions; do
6423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6424     ac_cv_prog_EXPECT="$ac_prog"
6425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6426     break 2
6427   fi
6428 done
6429 done
6430
6431 fi
6432 fi
6433 EXPECT=$ac_cv_prog_EXPECT
6434 if test -n "$EXPECT"; then
6435   echo "$as_me:$LINENO: result: $EXPECT" >&5
6436 echo "${ECHO_T}$EXPECT" >&6
6437 else
6438   echo "$as_me:$LINENO: result: no" >&5
6439 echo "${ECHO_T}no" >&6
6440 fi
6441
6442   test -n "$EXPECT" && break
6443 done
6444 test -n "$EXPECT" || EXPECT="expect"
6445
6446 case " $configdirs " in
6447   *" expect "*)
6448     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6449     ;;
6450 esac
6451
6452 for ac_prog in runtest
6453 do
6454   # Extract the first word of "$ac_prog", so it can be a program name with args.
6455 set dummy $ac_prog; ac_word=$2
6456 echo "$as_me:$LINENO: checking for $ac_word" >&5
6457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6458 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6459   echo $ECHO_N "(cached) $ECHO_C" >&6
6460 else
6461   if test -n "$RUNTEST"; then
6462   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6463 else
6464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6465 for as_dir in $PATH
6466 do
6467   IFS=$as_save_IFS
6468   test -z "$as_dir" && as_dir=.
6469   for ac_exec_ext in '' $ac_executable_extensions; do
6470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6471     ac_cv_prog_RUNTEST="$ac_prog"
6472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6473     break 2
6474   fi
6475 done
6476 done
6477
6478 fi
6479 fi
6480 RUNTEST=$ac_cv_prog_RUNTEST
6481 if test -n "$RUNTEST"; then
6482   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6483 echo "${ECHO_T}$RUNTEST" >&6
6484 else
6485   echo "$as_me:$LINENO: result: no" >&5
6486 echo "${ECHO_T}no" >&6
6487 fi
6488
6489   test -n "$RUNTEST" && break
6490 done
6491 test -n "$RUNTEST" || RUNTEST="runtest"
6492
6493 case " $configdirs " in
6494   *" dejagnu "*)
6495     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6496     ;;
6497 esac
6498
6499
6500 # Host tools.
6501 ncn_tool_prefix=
6502 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6503 ncn_target_tool_prefix=
6504 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6505
6506
6507
6508 if test -n "$AR"; then
6509   ac_cv_prog_AR=$AR
6510 elif test -n "$ac_cv_prog_AR"; then
6511   AR=$ac_cv_prog_AR
6512 fi
6513
6514 if test -n "$ac_cv_prog_AR"; then
6515   for ncn_progname in ar; do
6516     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6517 set dummy ${ncn_progname}; ac_word=$2
6518 echo "$as_me:$LINENO: checking for $ac_word" >&5
6519 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6520 if test "${ac_cv_prog_AR+set}" = set; then
6521   echo $ECHO_N "(cached) $ECHO_C" >&6
6522 else
6523   if test -n "$AR"; then
6524   ac_cv_prog_AR="$AR" # Let the user override the test.
6525 else
6526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6527 for as_dir in $PATH
6528 do
6529   IFS=$as_save_IFS
6530   test -z "$as_dir" && as_dir=.
6531   for ac_exec_ext in '' $ac_executable_extensions; do
6532   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6533     ac_cv_prog_AR="${ncn_progname}"
6534     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6535     break 2
6536   fi
6537 done
6538 done
6539
6540 fi
6541 fi
6542 AR=$ac_cv_prog_AR
6543 if test -n "$AR"; then
6544   echo "$as_me:$LINENO: result: $AR" >&5
6545 echo "${ECHO_T}$AR" >&6
6546 else
6547   echo "$as_me:$LINENO: result: no" >&5
6548 echo "${ECHO_T}no" >&6
6549 fi
6550
6551   done
6552 fi
6553
6554 for ncn_progname in ar; do
6555   if test -n "$ncn_tool_prefix"; then
6556     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6557 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6558 echo "$as_me:$LINENO: checking for $ac_word" >&5
6559 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6560 if test "${ac_cv_prog_AR+set}" = set; then
6561   echo $ECHO_N "(cached) $ECHO_C" >&6
6562 else
6563   if test -n "$AR"; then
6564   ac_cv_prog_AR="$AR" # Let the user override the test.
6565 else
6566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6567 for as_dir in $PATH
6568 do
6569   IFS=$as_save_IFS
6570   test -z "$as_dir" && as_dir=.
6571   for ac_exec_ext in '' $ac_executable_extensions; do
6572   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6573     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6574     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6575     break 2
6576   fi
6577 done
6578 done
6579
6580 fi
6581 fi
6582 AR=$ac_cv_prog_AR
6583 if test -n "$AR"; then
6584   echo "$as_me:$LINENO: result: $AR" >&5
6585 echo "${ECHO_T}$AR" >&6
6586 else
6587   echo "$as_me:$LINENO: result: no" >&5
6588 echo "${ECHO_T}no" >&6
6589 fi
6590
6591   fi
6592   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6593     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6594 set dummy ${ncn_progname}; ac_word=$2
6595 echo "$as_me:$LINENO: checking for $ac_word" >&5
6596 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6597 if test "${ac_cv_prog_AR+set}" = set; then
6598   echo $ECHO_N "(cached) $ECHO_C" >&6
6599 else
6600   if test -n "$AR"; then
6601   ac_cv_prog_AR="$AR" # Let the user override the test.
6602 else
6603 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6604 for as_dir in $PATH
6605 do
6606   IFS=$as_save_IFS
6607   test -z "$as_dir" && as_dir=.
6608   for ac_exec_ext in '' $ac_executable_extensions; do
6609   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6610     ac_cv_prog_AR="${ncn_progname}"
6611     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6612     break 2
6613   fi
6614 done
6615 done
6616
6617 fi
6618 fi
6619 AR=$ac_cv_prog_AR
6620 if test -n "$AR"; then
6621   echo "$as_me:$LINENO: result: $AR" >&5
6622 echo "${ECHO_T}$AR" >&6
6623 else
6624   echo "$as_me:$LINENO: result: no" >&5
6625 echo "${ECHO_T}no" >&6
6626 fi
6627
6628   fi
6629   test -n "$ac_cv_prog_AR" && break
6630 done
6631
6632 if test -z "$ac_cv_prog_AR" ; then
6633   set dummy ar
6634   if test $build = $host ; then
6635     AR="$2"
6636   else
6637     AR="${ncn_tool_prefix}$2"
6638   fi
6639 fi
6640
6641
6642
6643 if test -n "$AS"; then
6644   ac_cv_prog_AS=$AS
6645 elif test -n "$ac_cv_prog_AS"; then
6646   AS=$ac_cv_prog_AS
6647 fi
6648
6649 if test -n "$ac_cv_prog_AS"; then
6650   for ncn_progname in as; do
6651     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6652 set dummy ${ncn_progname}; ac_word=$2
6653 echo "$as_me:$LINENO: checking for $ac_word" >&5
6654 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6655 if test "${ac_cv_prog_AS+set}" = set; then
6656   echo $ECHO_N "(cached) $ECHO_C" >&6
6657 else
6658   if test -n "$AS"; then
6659   ac_cv_prog_AS="$AS" # Let the user override the test.
6660 else
6661 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6662 for as_dir in $PATH
6663 do
6664   IFS=$as_save_IFS
6665   test -z "$as_dir" && as_dir=.
6666   for ac_exec_ext in '' $ac_executable_extensions; do
6667   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6668     ac_cv_prog_AS="${ncn_progname}"
6669     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6670     break 2
6671   fi
6672 done
6673 done
6674
6675 fi
6676 fi
6677 AS=$ac_cv_prog_AS
6678 if test -n "$AS"; then
6679   echo "$as_me:$LINENO: result: $AS" >&5
6680 echo "${ECHO_T}$AS" >&6
6681 else
6682   echo "$as_me:$LINENO: result: no" >&5
6683 echo "${ECHO_T}no" >&6
6684 fi
6685
6686   done
6687 fi
6688
6689 for ncn_progname in as; do
6690   if test -n "$ncn_tool_prefix"; then
6691     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6692 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6693 echo "$as_me:$LINENO: checking for $ac_word" >&5
6694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6695 if test "${ac_cv_prog_AS+set}" = set; then
6696   echo $ECHO_N "(cached) $ECHO_C" >&6
6697 else
6698   if test -n "$AS"; then
6699   ac_cv_prog_AS="$AS" # Let the user override the test.
6700 else
6701 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6702 for as_dir in $PATH
6703 do
6704   IFS=$as_save_IFS
6705   test -z "$as_dir" && as_dir=.
6706   for ac_exec_ext in '' $ac_executable_extensions; do
6707   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6708     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6709     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6710     break 2
6711   fi
6712 done
6713 done
6714
6715 fi
6716 fi
6717 AS=$ac_cv_prog_AS
6718 if test -n "$AS"; then
6719   echo "$as_me:$LINENO: result: $AS" >&5
6720 echo "${ECHO_T}$AS" >&6
6721 else
6722   echo "$as_me:$LINENO: result: no" >&5
6723 echo "${ECHO_T}no" >&6
6724 fi
6725
6726   fi
6727   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6728     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6729 set dummy ${ncn_progname}; ac_word=$2
6730 echo "$as_me:$LINENO: checking for $ac_word" >&5
6731 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6732 if test "${ac_cv_prog_AS+set}" = set; then
6733   echo $ECHO_N "(cached) $ECHO_C" >&6
6734 else
6735   if test -n "$AS"; then
6736   ac_cv_prog_AS="$AS" # Let the user override the test.
6737 else
6738 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6739 for as_dir in $PATH
6740 do
6741   IFS=$as_save_IFS
6742   test -z "$as_dir" && as_dir=.
6743   for ac_exec_ext in '' $ac_executable_extensions; do
6744   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6745     ac_cv_prog_AS="${ncn_progname}"
6746     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6747     break 2
6748   fi
6749 done
6750 done
6751
6752 fi
6753 fi
6754 AS=$ac_cv_prog_AS
6755 if test -n "$AS"; then
6756   echo "$as_me:$LINENO: result: $AS" >&5
6757 echo "${ECHO_T}$AS" >&6
6758 else
6759   echo "$as_me:$LINENO: result: no" >&5
6760 echo "${ECHO_T}no" >&6
6761 fi
6762
6763   fi
6764   test -n "$ac_cv_prog_AS" && break
6765 done
6766
6767 if test -z "$ac_cv_prog_AS" ; then
6768   set dummy as
6769   if test $build = $host ; then
6770     AS="$2"
6771   else
6772     AS="${ncn_tool_prefix}$2"
6773   fi
6774 fi
6775
6776
6777
6778 if test -n "$DLLTOOL"; then
6779   ac_cv_prog_DLLTOOL=$DLLTOOL
6780 elif test -n "$ac_cv_prog_DLLTOOL"; then
6781   DLLTOOL=$ac_cv_prog_DLLTOOL
6782 fi
6783
6784 if test -n "$ac_cv_prog_DLLTOOL"; then
6785   for ncn_progname in dlltool; do
6786     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6787 set dummy ${ncn_progname}; ac_word=$2
6788 echo "$as_me:$LINENO: checking for $ac_word" >&5
6789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6790 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6791   echo $ECHO_N "(cached) $ECHO_C" >&6
6792 else
6793   if test -n "$DLLTOOL"; then
6794   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6795 else
6796 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6797 for as_dir in $PATH
6798 do
6799   IFS=$as_save_IFS
6800   test -z "$as_dir" && as_dir=.
6801   for ac_exec_ext in '' $ac_executable_extensions; do
6802   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6803     ac_cv_prog_DLLTOOL="${ncn_progname}"
6804     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6805     break 2
6806   fi
6807 done
6808 done
6809
6810 fi
6811 fi
6812 DLLTOOL=$ac_cv_prog_DLLTOOL
6813 if test -n "$DLLTOOL"; then
6814   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6815 echo "${ECHO_T}$DLLTOOL" >&6
6816 else
6817   echo "$as_me:$LINENO: result: no" >&5
6818 echo "${ECHO_T}no" >&6
6819 fi
6820
6821   done
6822 fi
6823
6824 for ncn_progname in dlltool; do
6825   if test -n "$ncn_tool_prefix"; then
6826     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6827 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6828 echo "$as_me:$LINENO: checking for $ac_word" >&5
6829 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6830 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6831   echo $ECHO_N "(cached) $ECHO_C" >&6
6832 else
6833   if test -n "$DLLTOOL"; then
6834   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6835 else
6836 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6837 for as_dir in $PATH
6838 do
6839   IFS=$as_save_IFS
6840   test -z "$as_dir" && as_dir=.
6841   for ac_exec_ext in '' $ac_executable_extensions; do
6842   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6843     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6844     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6845     break 2
6846   fi
6847 done
6848 done
6849
6850 fi
6851 fi
6852 DLLTOOL=$ac_cv_prog_DLLTOOL
6853 if test -n "$DLLTOOL"; then
6854   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6855 echo "${ECHO_T}$DLLTOOL" >&6
6856 else
6857   echo "$as_me:$LINENO: result: no" >&5
6858 echo "${ECHO_T}no" >&6
6859 fi
6860
6861   fi
6862   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6863     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6864 set dummy ${ncn_progname}; ac_word=$2
6865 echo "$as_me:$LINENO: checking for $ac_word" >&5
6866 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6867 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6868   echo $ECHO_N "(cached) $ECHO_C" >&6
6869 else
6870   if test -n "$DLLTOOL"; then
6871   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6872 else
6873 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6874 for as_dir in $PATH
6875 do
6876   IFS=$as_save_IFS
6877   test -z "$as_dir" && as_dir=.
6878   for ac_exec_ext in '' $ac_executable_extensions; do
6879   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6880     ac_cv_prog_DLLTOOL="${ncn_progname}"
6881     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6882     break 2
6883   fi
6884 done
6885 done
6886
6887 fi
6888 fi
6889 DLLTOOL=$ac_cv_prog_DLLTOOL
6890 if test -n "$DLLTOOL"; then
6891   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6892 echo "${ECHO_T}$DLLTOOL" >&6
6893 else
6894   echo "$as_me:$LINENO: result: no" >&5
6895 echo "${ECHO_T}no" >&6
6896 fi
6897
6898   fi
6899   test -n "$ac_cv_prog_DLLTOOL" && break
6900 done
6901
6902 if test -z "$ac_cv_prog_DLLTOOL" ; then
6903   set dummy dlltool
6904   if test $build = $host ; then
6905     DLLTOOL="$2"
6906   else
6907     DLLTOOL="${ncn_tool_prefix}$2"
6908   fi
6909 fi
6910
6911
6912
6913 if test -n "$LD"; then
6914   ac_cv_prog_LD=$LD
6915 elif test -n "$ac_cv_prog_LD"; then
6916   LD=$ac_cv_prog_LD
6917 fi
6918
6919 if test -n "$ac_cv_prog_LD"; then
6920   for ncn_progname in ld; do
6921     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6922 set dummy ${ncn_progname}; ac_word=$2
6923 echo "$as_me:$LINENO: checking for $ac_word" >&5
6924 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6925 if test "${ac_cv_prog_LD+set}" = set; then
6926   echo $ECHO_N "(cached) $ECHO_C" >&6
6927 else
6928   if test -n "$LD"; then
6929   ac_cv_prog_LD="$LD" # Let the user override the test.
6930 else
6931 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6932 for as_dir in $PATH
6933 do
6934   IFS=$as_save_IFS
6935   test -z "$as_dir" && as_dir=.
6936   for ac_exec_ext in '' $ac_executable_extensions; do
6937   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6938     ac_cv_prog_LD="${ncn_progname}"
6939     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6940     break 2
6941   fi
6942 done
6943 done
6944
6945 fi
6946 fi
6947 LD=$ac_cv_prog_LD
6948 if test -n "$LD"; then
6949   echo "$as_me:$LINENO: result: $LD" >&5
6950 echo "${ECHO_T}$LD" >&6
6951 else
6952   echo "$as_me:$LINENO: result: no" >&5
6953 echo "${ECHO_T}no" >&6
6954 fi
6955
6956   done
6957 fi
6958
6959 for ncn_progname in ld; do
6960   if test -n "$ncn_tool_prefix"; then
6961     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6962 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6963 echo "$as_me:$LINENO: checking for $ac_word" >&5
6964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6965 if test "${ac_cv_prog_LD+set}" = set; then
6966   echo $ECHO_N "(cached) $ECHO_C" >&6
6967 else
6968   if test -n "$LD"; then
6969   ac_cv_prog_LD="$LD" # Let the user override the test.
6970 else
6971 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6972 for as_dir in $PATH
6973 do
6974   IFS=$as_save_IFS
6975   test -z "$as_dir" && as_dir=.
6976   for ac_exec_ext in '' $ac_executable_extensions; do
6977   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6978     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6979     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6980     break 2
6981   fi
6982 done
6983 done
6984
6985 fi
6986 fi
6987 LD=$ac_cv_prog_LD
6988 if test -n "$LD"; then
6989   echo "$as_me:$LINENO: result: $LD" >&5
6990 echo "${ECHO_T}$LD" >&6
6991 else
6992   echo "$as_me:$LINENO: result: no" >&5
6993 echo "${ECHO_T}no" >&6
6994 fi
6995
6996   fi
6997   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6998     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6999 set dummy ${ncn_progname}; ac_word=$2
7000 echo "$as_me:$LINENO: checking for $ac_word" >&5
7001 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7002 if test "${ac_cv_prog_LD+set}" = set; then
7003   echo $ECHO_N "(cached) $ECHO_C" >&6
7004 else
7005   if test -n "$LD"; then
7006   ac_cv_prog_LD="$LD" # Let the user override the test.
7007 else
7008 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7009 for as_dir in $PATH
7010 do
7011   IFS=$as_save_IFS
7012   test -z "$as_dir" && as_dir=.
7013   for ac_exec_ext in '' $ac_executable_extensions; do
7014   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7015     ac_cv_prog_LD="${ncn_progname}"
7016     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7017     break 2
7018   fi
7019 done
7020 done
7021
7022 fi
7023 fi
7024 LD=$ac_cv_prog_LD
7025 if test -n "$LD"; then
7026   echo "$as_me:$LINENO: result: $LD" >&5
7027 echo "${ECHO_T}$LD" >&6
7028 else
7029   echo "$as_me:$LINENO: result: no" >&5
7030 echo "${ECHO_T}no" >&6
7031 fi
7032
7033   fi
7034   test -n "$ac_cv_prog_LD" && break
7035 done
7036
7037 if test -z "$ac_cv_prog_LD" ; then
7038   set dummy ld
7039   if test $build = $host ; then
7040     LD="$2"
7041   else
7042     LD="${ncn_tool_prefix}$2"
7043   fi
7044 fi
7045
7046
7047
7048 if test -n "$LIPO"; then
7049   ac_cv_prog_LIPO=$LIPO
7050 elif test -n "$ac_cv_prog_LIPO"; then
7051   LIPO=$ac_cv_prog_LIPO
7052 fi
7053
7054 if test -n "$ac_cv_prog_LIPO"; then
7055   for ncn_progname in lipo; do
7056     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7057 set dummy ${ncn_progname}; ac_word=$2
7058 echo "$as_me:$LINENO: checking for $ac_word" >&5
7059 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7060 if test "${ac_cv_prog_LIPO+set}" = set; then
7061   echo $ECHO_N "(cached) $ECHO_C" >&6
7062 else
7063   if test -n "$LIPO"; then
7064   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7065 else
7066 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7067 for as_dir in $PATH
7068 do
7069   IFS=$as_save_IFS
7070   test -z "$as_dir" && as_dir=.
7071   for ac_exec_ext in '' $ac_executable_extensions; do
7072   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7073     ac_cv_prog_LIPO="${ncn_progname}"
7074     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7075     break 2
7076   fi
7077 done
7078 done
7079
7080 fi
7081 fi
7082 LIPO=$ac_cv_prog_LIPO
7083 if test -n "$LIPO"; then
7084   echo "$as_me:$LINENO: result: $LIPO" >&5
7085 echo "${ECHO_T}$LIPO" >&6
7086 else
7087   echo "$as_me:$LINENO: result: no" >&5
7088 echo "${ECHO_T}no" >&6
7089 fi
7090
7091   done
7092 fi
7093
7094 for ncn_progname in lipo; do
7095   if test -n "$ncn_tool_prefix"; then
7096     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7097 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7098 echo "$as_me:$LINENO: checking for $ac_word" >&5
7099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7100 if test "${ac_cv_prog_LIPO+set}" = set; then
7101   echo $ECHO_N "(cached) $ECHO_C" >&6
7102 else
7103   if test -n "$LIPO"; then
7104   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7105 else
7106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7107 for as_dir in $PATH
7108 do
7109   IFS=$as_save_IFS
7110   test -z "$as_dir" && as_dir=.
7111   for ac_exec_ext in '' $ac_executable_extensions; do
7112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7113     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7115     break 2
7116   fi
7117 done
7118 done
7119
7120 fi
7121 fi
7122 LIPO=$ac_cv_prog_LIPO
7123 if test -n "$LIPO"; then
7124   echo "$as_me:$LINENO: result: $LIPO" >&5
7125 echo "${ECHO_T}$LIPO" >&6
7126 else
7127   echo "$as_me:$LINENO: result: no" >&5
7128 echo "${ECHO_T}no" >&6
7129 fi
7130
7131   fi
7132   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7133     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7134 set dummy ${ncn_progname}; ac_word=$2
7135 echo "$as_me:$LINENO: checking for $ac_word" >&5
7136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7137 if test "${ac_cv_prog_LIPO+set}" = set; then
7138   echo $ECHO_N "(cached) $ECHO_C" >&6
7139 else
7140   if test -n "$LIPO"; then
7141   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7142 else
7143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7144 for as_dir in $PATH
7145 do
7146   IFS=$as_save_IFS
7147   test -z "$as_dir" && as_dir=.
7148   for ac_exec_ext in '' $ac_executable_extensions; do
7149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7150     ac_cv_prog_LIPO="${ncn_progname}"
7151     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7152     break 2
7153   fi
7154 done
7155 done
7156
7157 fi
7158 fi
7159 LIPO=$ac_cv_prog_LIPO
7160 if test -n "$LIPO"; then
7161   echo "$as_me:$LINENO: result: $LIPO" >&5
7162 echo "${ECHO_T}$LIPO" >&6
7163 else
7164   echo "$as_me:$LINENO: result: no" >&5
7165 echo "${ECHO_T}no" >&6
7166 fi
7167
7168   fi
7169   test -n "$ac_cv_prog_LIPO" && break
7170 done
7171
7172 if test -z "$ac_cv_prog_LIPO" ; then
7173   set dummy lipo
7174   if test $build = $host ; then
7175     LIPO="$2"
7176   else
7177     LIPO="${ncn_tool_prefix}$2"
7178   fi
7179 fi
7180
7181
7182
7183 if test -n "$NM"; then
7184   ac_cv_prog_NM=$NM
7185 elif test -n "$ac_cv_prog_NM"; then
7186   NM=$ac_cv_prog_NM
7187 fi
7188
7189 if test -n "$ac_cv_prog_NM"; then
7190   for ncn_progname in nm; do
7191     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7192 set dummy ${ncn_progname}; ac_word=$2
7193 echo "$as_me:$LINENO: checking for $ac_word" >&5
7194 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7195 if test "${ac_cv_prog_NM+set}" = set; then
7196   echo $ECHO_N "(cached) $ECHO_C" >&6
7197 else
7198   if test -n "$NM"; then
7199   ac_cv_prog_NM="$NM" # Let the user override the test.
7200 else
7201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7202 for as_dir in $PATH
7203 do
7204   IFS=$as_save_IFS
7205   test -z "$as_dir" && as_dir=.
7206   for ac_exec_ext in '' $ac_executable_extensions; do
7207   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7208     ac_cv_prog_NM="${ncn_progname}"
7209     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7210     break 2
7211   fi
7212 done
7213 done
7214
7215 fi
7216 fi
7217 NM=$ac_cv_prog_NM
7218 if test -n "$NM"; then
7219   echo "$as_me:$LINENO: result: $NM" >&5
7220 echo "${ECHO_T}$NM" >&6
7221 else
7222   echo "$as_me:$LINENO: result: no" >&5
7223 echo "${ECHO_T}no" >&6
7224 fi
7225
7226   done
7227 fi
7228
7229 for ncn_progname in nm; do
7230   if test -n "$ncn_tool_prefix"; then
7231     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7232 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7233 echo "$as_me:$LINENO: checking for $ac_word" >&5
7234 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7235 if test "${ac_cv_prog_NM+set}" = set; then
7236   echo $ECHO_N "(cached) $ECHO_C" >&6
7237 else
7238   if test -n "$NM"; then
7239   ac_cv_prog_NM="$NM" # Let the user override the test.
7240 else
7241 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7242 for as_dir in $PATH
7243 do
7244   IFS=$as_save_IFS
7245   test -z "$as_dir" && as_dir=.
7246   for ac_exec_ext in '' $ac_executable_extensions; do
7247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7248     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7250     break 2
7251   fi
7252 done
7253 done
7254
7255 fi
7256 fi
7257 NM=$ac_cv_prog_NM
7258 if test -n "$NM"; then
7259   echo "$as_me:$LINENO: result: $NM" >&5
7260 echo "${ECHO_T}$NM" >&6
7261 else
7262   echo "$as_me:$LINENO: result: no" >&5
7263 echo "${ECHO_T}no" >&6
7264 fi
7265
7266   fi
7267   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7268     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7269 set dummy ${ncn_progname}; ac_word=$2
7270 echo "$as_me:$LINENO: checking for $ac_word" >&5
7271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7272 if test "${ac_cv_prog_NM+set}" = set; then
7273   echo $ECHO_N "(cached) $ECHO_C" >&6
7274 else
7275   if test -n "$NM"; then
7276   ac_cv_prog_NM="$NM" # Let the user override the test.
7277 else
7278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7279 for as_dir in $PATH
7280 do
7281   IFS=$as_save_IFS
7282   test -z "$as_dir" && as_dir=.
7283   for ac_exec_ext in '' $ac_executable_extensions; do
7284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7285     ac_cv_prog_NM="${ncn_progname}"
7286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7287     break 2
7288   fi
7289 done
7290 done
7291
7292 fi
7293 fi
7294 NM=$ac_cv_prog_NM
7295 if test -n "$NM"; then
7296   echo "$as_me:$LINENO: result: $NM" >&5
7297 echo "${ECHO_T}$NM" >&6
7298 else
7299   echo "$as_me:$LINENO: result: no" >&5
7300 echo "${ECHO_T}no" >&6
7301 fi
7302
7303   fi
7304   test -n "$ac_cv_prog_NM" && break
7305 done
7306
7307 if test -z "$ac_cv_prog_NM" ; then
7308   set dummy nm
7309   if test $build = $host ; then
7310     NM="$2"
7311   else
7312     NM="${ncn_tool_prefix}$2"
7313   fi
7314 fi
7315
7316
7317
7318 if test -n "$RANLIB"; then
7319   ac_cv_prog_RANLIB=$RANLIB
7320 elif test -n "$ac_cv_prog_RANLIB"; then
7321   RANLIB=$ac_cv_prog_RANLIB
7322 fi
7323
7324 if test -n "$ac_cv_prog_RANLIB"; then
7325   for ncn_progname in ranlib; do
7326     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7327 set dummy ${ncn_progname}; ac_word=$2
7328 echo "$as_me:$LINENO: checking for $ac_word" >&5
7329 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7330 if test "${ac_cv_prog_RANLIB+set}" = set; then
7331   echo $ECHO_N "(cached) $ECHO_C" >&6
7332 else
7333   if test -n "$RANLIB"; then
7334   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7335 else
7336 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7337 for as_dir in $PATH
7338 do
7339   IFS=$as_save_IFS
7340   test -z "$as_dir" && as_dir=.
7341   for ac_exec_ext in '' $ac_executable_extensions; do
7342   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7343     ac_cv_prog_RANLIB="${ncn_progname}"
7344     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7345     break 2
7346   fi
7347 done
7348 done
7349
7350 fi
7351 fi
7352 RANLIB=$ac_cv_prog_RANLIB
7353 if test -n "$RANLIB"; then
7354   echo "$as_me:$LINENO: result: $RANLIB" >&5
7355 echo "${ECHO_T}$RANLIB" >&6
7356 else
7357   echo "$as_me:$LINENO: result: no" >&5
7358 echo "${ECHO_T}no" >&6
7359 fi
7360
7361   done
7362 fi
7363
7364 for ncn_progname in ranlib; do
7365   if test -n "$ncn_tool_prefix"; then
7366     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7367 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7368 echo "$as_me:$LINENO: checking for $ac_word" >&5
7369 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7370 if test "${ac_cv_prog_RANLIB+set}" = set; then
7371   echo $ECHO_N "(cached) $ECHO_C" >&6
7372 else
7373   if test -n "$RANLIB"; then
7374   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7375 else
7376 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7377 for as_dir in $PATH
7378 do
7379   IFS=$as_save_IFS
7380   test -z "$as_dir" && as_dir=.
7381   for ac_exec_ext in '' $ac_executable_extensions; do
7382   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7383     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7384     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7385     break 2
7386   fi
7387 done
7388 done
7389
7390 fi
7391 fi
7392 RANLIB=$ac_cv_prog_RANLIB
7393 if test -n "$RANLIB"; then
7394   echo "$as_me:$LINENO: result: $RANLIB" >&5
7395 echo "${ECHO_T}$RANLIB" >&6
7396 else
7397   echo "$as_me:$LINENO: result: no" >&5
7398 echo "${ECHO_T}no" >&6
7399 fi
7400
7401   fi
7402   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7403     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7404 set dummy ${ncn_progname}; ac_word=$2
7405 echo "$as_me:$LINENO: checking for $ac_word" >&5
7406 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7407 if test "${ac_cv_prog_RANLIB+set}" = set; then
7408   echo $ECHO_N "(cached) $ECHO_C" >&6
7409 else
7410   if test -n "$RANLIB"; then
7411   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7412 else
7413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7414 for as_dir in $PATH
7415 do
7416   IFS=$as_save_IFS
7417   test -z "$as_dir" && as_dir=.
7418   for ac_exec_ext in '' $ac_executable_extensions; do
7419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7420     ac_cv_prog_RANLIB="${ncn_progname}"
7421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7422     break 2
7423   fi
7424 done
7425 done
7426
7427 fi
7428 fi
7429 RANLIB=$ac_cv_prog_RANLIB
7430 if test -n "$RANLIB"; then
7431   echo "$as_me:$LINENO: result: $RANLIB" >&5
7432 echo "${ECHO_T}$RANLIB" >&6
7433 else
7434   echo "$as_me:$LINENO: result: no" >&5
7435 echo "${ECHO_T}no" >&6
7436 fi
7437
7438   fi
7439   test -n "$ac_cv_prog_RANLIB" && break
7440 done
7441
7442 if test -z "$ac_cv_prog_RANLIB" ; then
7443   RANLIB=":"
7444 fi
7445
7446
7447
7448 if test -n "$STRIP"; then
7449   ac_cv_prog_STRIP=$STRIP
7450 elif test -n "$ac_cv_prog_STRIP"; then
7451   STRIP=$ac_cv_prog_STRIP
7452 fi
7453
7454 if test -n "$ac_cv_prog_STRIP"; then
7455   for ncn_progname in strip; do
7456     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7457 set dummy ${ncn_progname}; ac_word=$2
7458 echo "$as_me:$LINENO: checking for $ac_word" >&5
7459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7460 if test "${ac_cv_prog_STRIP+set}" = set; then
7461   echo $ECHO_N "(cached) $ECHO_C" >&6
7462 else
7463   if test -n "$STRIP"; then
7464   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7465 else
7466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7467 for as_dir in $PATH
7468 do
7469   IFS=$as_save_IFS
7470   test -z "$as_dir" && as_dir=.
7471   for ac_exec_ext in '' $ac_executable_extensions; do
7472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7473     ac_cv_prog_STRIP="${ncn_progname}"
7474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7475     break 2
7476   fi
7477 done
7478 done
7479
7480 fi
7481 fi
7482 STRIP=$ac_cv_prog_STRIP
7483 if test -n "$STRIP"; then
7484   echo "$as_me:$LINENO: result: $STRIP" >&5
7485 echo "${ECHO_T}$STRIP" >&6
7486 else
7487   echo "$as_me:$LINENO: result: no" >&5
7488 echo "${ECHO_T}no" >&6
7489 fi
7490
7491   done
7492 fi
7493
7494 for ncn_progname in strip; do
7495   if test -n "$ncn_tool_prefix"; then
7496     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7497 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7498 echo "$as_me:$LINENO: checking for $ac_word" >&5
7499 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7500 if test "${ac_cv_prog_STRIP+set}" = set; then
7501   echo $ECHO_N "(cached) $ECHO_C" >&6
7502 else
7503   if test -n "$STRIP"; then
7504   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7505 else
7506 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7507 for as_dir in $PATH
7508 do
7509   IFS=$as_save_IFS
7510   test -z "$as_dir" && as_dir=.
7511   for ac_exec_ext in '' $ac_executable_extensions; do
7512   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7513     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7514     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7515     break 2
7516   fi
7517 done
7518 done
7519
7520 fi
7521 fi
7522 STRIP=$ac_cv_prog_STRIP
7523 if test -n "$STRIP"; then
7524   echo "$as_me:$LINENO: result: $STRIP" >&5
7525 echo "${ECHO_T}$STRIP" >&6
7526 else
7527   echo "$as_me:$LINENO: result: no" >&5
7528 echo "${ECHO_T}no" >&6
7529 fi
7530
7531   fi
7532   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7533     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7534 set dummy ${ncn_progname}; ac_word=$2
7535 echo "$as_me:$LINENO: checking for $ac_word" >&5
7536 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7537 if test "${ac_cv_prog_STRIP+set}" = set; then
7538   echo $ECHO_N "(cached) $ECHO_C" >&6
7539 else
7540   if test -n "$STRIP"; then
7541   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7542 else
7543 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7544 for as_dir in $PATH
7545 do
7546   IFS=$as_save_IFS
7547   test -z "$as_dir" && as_dir=.
7548   for ac_exec_ext in '' $ac_executable_extensions; do
7549   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7550     ac_cv_prog_STRIP="${ncn_progname}"
7551     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7552     break 2
7553   fi
7554 done
7555 done
7556
7557 fi
7558 fi
7559 STRIP=$ac_cv_prog_STRIP
7560 if test -n "$STRIP"; then
7561   echo "$as_me:$LINENO: result: $STRIP" >&5
7562 echo "${ECHO_T}$STRIP" >&6
7563 else
7564   echo "$as_me:$LINENO: result: no" >&5
7565 echo "${ECHO_T}no" >&6
7566 fi
7567
7568   fi
7569   test -n "$ac_cv_prog_STRIP" && break
7570 done
7571
7572 if test -z "$ac_cv_prog_STRIP" ; then
7573   STRIP=":"
7574 fi
7575
7576
7577
7578 if test -n "$WINDRES"; then
7579   ac_cv_prog_WINDRES=$WINDRES
7580 elif test -n "$ac_cv_prog_WINDRES"; then
7581   WINDRES=$ac_cv_prog_WINDRES
7582 fi
7583
7584 if test -n "$ac_cv_prog_WINDRES"; then
7585   for ncn_progname in windres; do
7586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7587 set dummy ${ncn_progname}; ac_word=$2
7588 echo "$as_me:$LINENO: checking for $ac_word" >&5
7589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7590 if test "${ac_cv_prog_WINDRES+set}" = set; then
7591   echo $ECHO_N "(cached) $ECHO_C" >&6
7592 else
7593   if test -n "$WINDRES"; then
7594   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7595 else
7596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7597 for as_dir in $PATH
7598 do
7599   IFS=$as_save_IFS
7600   test -z "$as_dir" && as_dir=.
7601   for ac_exec_ext in '' $ac_executable_extensions; do
7602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7603     ac_cv_prog_WINDRES="${ncn_progname}"
7604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7605     break 2
7606   fi
7607 done
7608 done
7609
7610 fi
7611 fi
7612 WINDRES=$ac_cv_prog_WINDRES
7613 if test -n "$WINDRES"; then
7614   echo "$as_me:$LINENO: result: $WINDRES" >&5
7615 echo "${ECHO_T}$WINDRES" >&6
7616 else
7617   echo "$as_me:$LINENO: result: no" >&5
7618 echo "${ECHO_T}no" >&6
7619 fi
7620
7621   done
7622 fi
7623
7624 for ncn_progname in windres; do
7625   if test -n "$ncn_tool_prefix"; then
7626     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7627 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7628 echo "$as_me:$LINENO: checking for $ac_word" >&5
7629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7630 if test "${ac_cv_prog_WINDRES+set}" = set; then
7631   echo $ECHO_N "(cached) $ECHO_C" >&6
7632 else
7633   if test -n "$WINDRES"; then
7634   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7635 else
7636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7637 for as_dir in $PATH
7638 do
7639   IFS=$as_save_IFS
7640   test -z "$as_dir" && as_dir=.
7641   for ac_exec_ext in '' $ac_executable_extensions; do
7642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7643     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7645     break 2
7646   fi
7647 done
7648 done
7649
7650 fi
7651 fi
7652 WINDRES=$ac_cv_prog_WINDRES
7653 if test -n "$WINDRES"; then
7654   echo "$as_me:$LINENO: result: $WINDRES" >&5
7655 echo "${ECHO_T}$WINDRES" >&6
7656 else
7657   echo "$as_me:$LINENO: result: no" >&5
7658 echo "${ECHO_T}no" >&6
7659 fi
7660
7661   fi
7662   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7663     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7664 set dummy ${ncn_progname}; ac_word=$2
7665 echo "$as_me:$LINENO: checking for $ac_word" >&5
7666 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7667 if test "${ac_cv_prog_WINDRES+set}" = set; then
7668   echo $ECHO_N "(cached) $ECHO_C" >&6
7669 else
7670   if test -n "$WINDRES"; then
7671   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7672 else
7673 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7674 for as_dir in $PATH
7675 do
7676   IFS=$as_save_IFS
7677   test -z "$as_dir" && as_dir=.
7678   for ac_exec_ext in '' $ac_executable_extensions; do
7679   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7680     ac_cv_prog_WINDRES="${ncn_progname}"
7681     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7682     break 2
7683   fi
7684 done
7685 done
7686
7687 fi
7688 fi
7689 WINDRES=$ac_cv_prog_WINDRES
7690 if test -n "$WINDRES"; then
7691   echo "$as_me:$LINENO: result: $WINDRES" >&5
7692 echo "${ECHO_T}$WINDRES" >&6
7693 else
7694   echo "$as_me:$LINENO: result: no" >&5
7695 echo "${ECHO_T}no" >&6
7696 fi
7697
7698   fi
7699   test -n "$ac_cv_prog_WINDRES" && break
7700 done
7701
7702 if test -z "$ac_cv_prog_WINDRES" ; then
7703   set dummy windres
7704   if test $build = $host ; then
7705     WINDRES="$2"
7706   else
7707     WINDRES="${ncn_tool_prefix}$2"
7708   fi
7709 fi
7710
7711
7712
7713 if test -n "$WINDMC"; then
7714   ac_cv_prog_WINDMC=$WINDMC
7715 elif test -n "$ac_cv_prog_WINDMC"; then
7716   WINDMC=$ac_cv_prog_WINDMC
7717 fi
7718
7719 if test -n "$ac_cv_prog_WINDMC"; then
7720   for ncn_progname in windmc; do
7721     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7722 set dummy ${ncn_progname}; ac_word=$2
7723 echo "$as_me:$LINENO: checking for $ac_word" >&5
7724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7725 if test "${ac_cv_prog_WINDMC+set}" = set; then
7726   echo $ECHO_N "(cached) $ECHO_C" >&6
7727 else
7728   if test -n "$WINDMC"; then
7729   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7730 else
7731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7732 for as_dir in $PATH
7733 do
7734   IFS=$as_save_IFS
7735   test -z "$as_dir" && as_dir=.
7736   for ac_exec_ext in '' $ac_executable_extensions; do
7737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7738     ac_cv_prog_WINDMC="${ncn_progname}"
7739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7740     break 2
7741   fi
7742 done
7743 done
7744
7745 fi
7746 fi
7747 WINDMC=$ac_cv_prog_WINDMC
7748 if test -n "$WINDMC"; then
7749   echo "$as_me:$LINENO: result: $WINDMC" >&5
7750 echo "${ECHO_T}$WINDMC" >&6
7751 else
7752   echo "$as_me:$LINENO: result: no" >&5
7753 echo "${ECHO_T}no" >&6
7754 fi
7755
7756   done
7757 fi
7758
7759 for ncn_progname in windmc; do
7760   if test -n "$ncn_tool_prefix"; then
7761     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7762 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7763 echo "$as_me:$LINENO: checking for $ac_word" >&5
7764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7765 if test "${ac_cv_prog_WINDMC+set}" = set; then
7766   echo $ECHO_N "(cached) $ECHO_C" >&6
7767 else
7768   if test -n "$WINDMC"; then
7769   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7770 else
7771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7772 for as_dir in $PATH
7773 do
7774   IFS=$as_save_IFS
7775   test -z "$as_dir" && as_dir=.
7776   for ac_exec_ext in '' $ac_executable_extensions; do
7777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7778     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7780     break 2
7781   fi
7782 done
7783 done
7784
7785 fi
7786 fi
7787 WINDMC=$ac_cv_prog_WINDMC
7788 if test -n "$WINDMC"; then
7789   echo "$as_me:$LINENO: result: $WINDMC" >&5
7790 echo "${ECHO_T}$WINDMC" >&6
7791 else
7792   echo "$as_me:$LINENO: result: no" >&5
7793 echo "${ECHO_T}no" >&6
7794 fi
7795
7796   fi
7797   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7798     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7799 set dummy ${ncn_progname}; ac_word=$2
7800 echo "$as_me:$LINENO: checking for $ac_word" >&5
7801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7802 if test "${ac_cv_prog_WINDMC+set}" = set; then
7803   echo $ECHO_N "(cached) $ECHO_C" >&6
7804 else
7805   if test -n "$WINDMC"; then
7806   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7807 else
7808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7809 for as_dir in $PATH
7810 do
7811   IFS=$as_save_IFS
7812   test -z "$as_dir" && as_dir=.
7813   for ac_exec_ext in '' $ac_executable_extensions; do
7814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7815     ac_cv_prog_WINDMC="${ncn_progname}"
7816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7817     break 2
7818   fi
7819 done
7820 done
7821
7822 fi
7823 fi
7824 WINDMC=$ac_cv_prog_WINDMC
7825 if test -n "$WINDMC"; then
7826   echo "$as_me:$LINENO: result: $WINDMC" >&5
7827 echo "${ECHO_T}$WINDMC" >&6
7828 else
7829   echo "$as_me:$LINENO: result: no" >&5
7830 echo "${ECHO_T}no" >&6
7831 fi
7832
7833   fi
7834   test -n "$ac_cv_prog_WINDMC" && break
7835 done
7836
7837 if test -z "$ac_cv_prog_WINDMC" ; then
7838   set dummy windmc
7839   if test $build = $host ; then
7840     WINDMC="$2"
7841   else
7842     WINDMC="${ncn_tool_prefix}$2"
7843   fi
7844 fi
7845
7846
7847
7848 if test -n "$OBJCOPY"; then
7849   ac_cv_prog_OBJCOPY=$OBJCOPY
7850 elif test -n "$ac_cv_prog_OBJCOPY"; then
7851   OBJCOPY=$ac_cv_prog_OBJCOPY
7852 fi
7853
7854 if test -n "$ac_cv_prog_OBJCOPY"; then
7855   for ncn_progname in objcopy; do
7856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7857 set dummy ${ncn_progname}; ac_word=$2
7858 echo "$as_me:$LINENO: checking for $ac_word" >&5
7859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7860 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7861   echo $ECHO_N "(cached) $ECHO_C" >&6
7862 else
7863   if test -n "$OBJCOPY"; then
7864   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7865 else
7866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7867 for as_dir in $PATH
7868 do
7869   IFS=$as_save_IFS
7870   test -z "$as_dir" && as_dir=.
7871   for ac_exec_ext in '' $ac_executable_extensions; do
7872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7873     ac_cv_prog_OBJCOPY="${ncn_progname}"
7874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7875     break 2
7876   fi
7877 done
7878 done
7879
7880 fi
7881 fi
7882 OBJCOPY=$ac_cv_prog_OBJCOPY
7883 if test -n "$OBJCOPY"; then
7884   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7885 echo "${ECHO_T}$OBJCOPY" >&6
7886 else
7887   echo "$as_me:$LINENO: result: no" >&5
7888 echo "${ECHO_T}no" >&6
7889 fi
7890
7891   done
7892 fi
7893
7894 for ncn_progname in objcopy; do
7895   if test -n "$ncn_tool_prefix"; then
7896     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7897 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7898 echo "$as_me:$LINENO: checking for $ac_word" >&5
7899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7900 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7901   echo $ECHO_N "(cached) $ECHO_C" >&6
7902 else
7903   if test -n "$OBJCOPY"; then
7904   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7905 else
7906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7907 for as_dir in $PATH
7908 do
7909   IFS=$as_save_IFS
7910   test -z "$as_dir" && as_dir=.
7911   for ac_exec_ext in '' $ac_executable_extensions; do
7912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7913     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7915     break 2
7916   fi
7917 done
7918 done
7919
7920 fi
7921 fi
7922 OBJCOPY=$ac_cv_prog_OBJCOPY
7923 if test -n "$OBJCOPY"; then
7924   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7925 echo "${ECHO_T}$OBJCOPY" >&6
7926 else
7927   echo "$as_me:$LINENO: result: no" >&5
7928 echo "${ECHO_T}no" >&6
7929 fi
7930
7931   fi
7932   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7933     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7934 set dummy ${ncn_progname}; ac_word=$2
7935 echo "$as_me:$LINENO: checking for $ac_word" >&5
7936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7937 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7938   echo $ECHO_N "(cached) $ECHO_C" >&6
7939 else
7940   if test -n "$OBJCOPY"; then
7941   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7942 else
7943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7944 for as_dir in $PATH
7945 do
7946   IFS=$as_save_IFS
7947   test -z "$as_dir" && as_dir=.
7948   for ac_exec_ext in '' $ac_executable_extensions; do
7949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7950     ac_cv_prog_OBJCOPY="${ncn_progname}"
7951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7952     break 2
7953   fi
7954 done
7955 done
7956
7957 fi
7958 fi
7959 OBJCOPY=$ac_cv_prog_OBJCOPY
7960 if test -n "$OBJCOPY"; then
7961   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7962 echo "${ECHO_T}$OBJCOPY" >&6
7963 else
7964   echo "$as_me:$LINENO: result: no" >&5
7965 echo "${ECHO_T}no" >&6
7966 fi
7967
7968   fi
7969   test -n "$ac_cv_prog_OBJCOPY" && break
7970 done
7971
7972 if test -z "$ac_cv_prog_OBJCOPY" ; then
7973   set dummy objcopy
7974   if test $build = $host ; then
7975     OBJCOPY="$2"
7976   else
7977     OBJCOPY="${ncn_tool_prefix}$2"
7978   fi
7979 fi
7980
7981
7982
7983 if test -n "$OBJDUMP"; then
7984   ac_cv_prog_OBJDUMP=$OBJDUMP
7985 elif test -n "$ac_cv_prog_OBJDUMP"; then
7986   OBJDUMP=$ac_cv_prog_OBJDUMP
7987 fi
7988
7989 if test -n "$ac_cv_prog_OBJDUMP"; then
7990   for ncn_progname in objdump; do
7991     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7992 set dummy ${ncn_progname}; ac_word=$2
7993 echo "$as_me:$LINENO: checking for $ac_word" >&5
7994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7995 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7996   echo $ECHO_N "(cached) $ECHO_C" >&6
7997 else
7998   if test -n "$OBJDUMP"; then
7999   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8000 else
8001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8002 for as_dir in $PATH
8003 do
8004   IFS=$as_save_IFS
8005   test -z "$as_dir" && as_dir=.
8006   for ac_exec_ext in '' $ac_executable_extensions; do
8007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8008     ac_cv_prog_OBJDUMP="${ncn_progname}"
8009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8010     break 2
8011   fi
8012 done
8013 done
8014
8015 fi
8016 fi
8017 OBJDUMP=$ac_cv_prog_OBJDUMP
8018 if test -n "$OBJDUMP"; then
8019   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8020 echo "${ECHO_T}$OBJDUMP" >&6
8021 else
8022   echo "$as_me:$LINENO: result: no" >&5
8023 echo "${ECHO_T}no" >&6
8024 fi
8025
8026   done
8027 fi
8028
8029 for ncn_progname in objdump; do
8030   if test -n "$ncn_tool_prefix"; then
8031     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8032 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8033 echo "$as_me:$LINENO: checking for $ac_word" >&5
8034 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8035 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8036   echo $ECHO_N "(cached) $ECHO_C" >&6
8037 else
8038   if test -n "$OBJDUMP"; then
8039   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8040 else
8041 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8042 for as_dir in $PATH
8043 do
8044   IFS=$as_save_IFS
8045   test -z "$as_dir" && as_dir=.
8046   for ac_exec_ext in '' $ac_executable_extensions; do
8047   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8048     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8049     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8050     break 2
8051   fi
8052 done
8053 done
8054
8055 fi
8056 fi
8057 OBJDUMP=$ac_cv_prog_OBJDUMP
8058 if test -n "$OBJDUMP"; then
8059   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8060 echo "${ECHO_T}$OBJDUMP" >&6
8061 else
8062   echo "$as_me:$LINENO: result: no" >&5
8063 echo "${ECHO_T}no" >&6
8064 fi
8065
8066   fi
8067   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8068     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8069 set dummy ${ncn_progname}; ac_word=$2
8070 echo "$as_me:$LINENO: checking for $ac_word" >&5
8071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8072 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8073   echo $ECHO_N "(cached) $ECHO_C" >&6
8074 else
8075   if test -n "$OBJDUMP"; then
8076   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8077 else
8078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8079 for as_dir in $PATH
8080 do
8081   IFS=$as_save_IFS
8082   test -z "$as_dir" && as_dir=.
8083   for ac_exec_ext in '' $ac_executable_extensions; do
8084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8085     ac_cv_prog_OBJDUMP="${ncn_progname}"
8086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8087     break 2
8088   fi
8089 done
8090 done
8091
8092 fi
8093 fi
8094 OBJDUMP=$ac_cv_prog_OBJDUMP
8095 if test -n "$OBJDUMP"; then
8096   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8097 echo "${ECHO_T}$OBJDUMP" >&6
8098 else
8099   echo "$as_me:$LINENO: result: no" >&5
8100 echo "${ECHO_T}no" >&6
8101 fi
8102
8103   fi
8104   test -n "$ac_cv_prog_OBJDUMP" && break
8105 done
8106
8107 if test -z "$ac_cv_prog_OBJDUMP" ; then
8108   set dummy objdump
8109   if test $build = $host ; then
8110     OBJDUMP="$2"
8111   else
8112     OBJDUMP="${ncn_tool_prefix}$2"
8113   fi
8114 fi
8115
8116
8117
8118
8119
8120
8121 # Target tools.
8122
8123 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8124 if test "${with_build_time_tools+set}" = set; then
8125   withval="$with_build_time_tools"
8126   case x"$withval" in
8127      x/*) ;;
8128      *)
8129        with_build_time_tools=
8130        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8131 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8132        ;;
8133    esac
8134 else
8135   with_build_time_tools=
8136 fi;
8137
8138
8139
8140 if test -n "$CC_FOR_TARGET"; then
8141   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8142 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8143   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8144 fi
8145
8146 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8147   for ncn_progname in cc gcc; do
8148     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8149 set dummy ${ncn_progname}; ac_word=$2
8150 echo "$as_me:$LINENO: checking for $ac_word" >&5
8151 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8152 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8153   echo $ECHO_N "(cached) $ECHO_C" >&6
8154 else
8155   if test -n "$CC_FOR_TARGET"; then
8156   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8157 else
8158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8159 for as_dir in $PATH
8160 do
8161   IFS=$as_save_IFS
8162   test -z "$as_dir" && as_dir=.
8163   for ac_exec_ext in '' $ac_executable_extensions; do
8164   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8165     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8166     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8167     break 2
8168   fi
8169 done
8170 done
8171
8172 fi
8173 fi
8174 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8175 if test -n "$CC_FOR_TARGET"; then
8176   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8177 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8178 else
8179   echo "$as_me:$LINENO: result: no" >&5
8180 echo "${ECHO_T}no" >&6
8181 fi
8182
8183   done
8184 fi
8185
8186 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8187   for ncn_progname in cc gcc; do
8188     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8189 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8190     if test -x $with_build_time_tools/${ncn_progname}; then
8191       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8192       echo "$as_me:$LINENO: result: yes" >&5
8193 echo "${ECHO_T}yes" >&6
8194       break
8195     else
8196       echo "$as_me:$LINENO: result: no" >&5
8197 echo "${ECHO_T}no" >&6
8198     fi
8199   done
8200 fi
8201
8202 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8203   for ncn_progname in cc gcc; do
8204     if test -n "$ncn_target_tool_prefix"; then
8205       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8206 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8207 echo "$as_me:$LINENO: checking for $ac_word" >&5
8208 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8209 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8210   echo $ECHO_N "(cached) $ECHO_C" >&6
8211 else
8212   if test -n "$CC_FOR_TARGET"; then
8213   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8214 else
8215 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8216 for as_dir in $PATH
8217 do
8218   IFS=$as_save_IFS
8219   test -z "$as_dir" && as_dir=.
8220   for ac_exec_ext in '' $ac_executable_extensions; do
8221   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8222     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8223     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8224     break 2
8225   fi
8226 done
8227 done
8228
8229 fi
8230 fi
8231 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8232 if test -n "$CC_FOR_TARGET"; then
8233   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8234 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8235 else
8236   echo "$as_me:$LINENO: result: no" >&5
8237 echo "${ECHO_T}no" >&6
8238 fi
8239
8240     fi
8241     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8242       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8243 set dummy ${ncn_progname}; ac_word=$2
8244 echo "$as_me:$LINENO: checking for $ac_word" >&5
8245 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8246 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8247   echo $ECHO_N "(cached) $ECHO_C" >&6
8248 else
8249   if test -n "$CC_FOR_TARGET"; then
8250   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8251 else
8252 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8253 for as_dir in $PATH
8254 do
8255   IFS=$as_save_IFS
8256   test -z "$as_dir" && as_dir=.
8257   for ac_exec_ext in '' $ac_executable_extensions; do
8258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8259     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8261     break 2
8262   fi
8263 done
8264 done
8265
8266 fi
8267 fi
8268 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8269 if test -n "$CC_FOR_TARGET"; then
8270   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8271 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8272 else
8273   echo "$as_me:$LINENO: result: no" >&5
8274 echo "${ECHO_T}no" >&6
8275 fi
8276
8277     fi
8278     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8279   done
8280 fi
8281
8282 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8283   set dummy cc gcc
8284   if test $build = $target ; then
8285     CC_FOR_TARGET="$2"
8286   else
8287     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8288   fi
8289 else
8290   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8291 fi
8292
8293
8294
8295 if test -n "$CXX_FOR_TARGET"; then
8296   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8297 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8298   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8299 fi
8300
8301 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8302   for ncn_progname in c++ g++ cxx gxx; do
8303     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8304 set dummy ${ncn_progname}; ac_word=$2
8305 echo "$as_me:$LINENO: checking for $ac_word" >&5
8306 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8307 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8308   echo $ECHO_N "(cached) $ECHO_C" >&6
8309 else
8310   if test -n "$CXX_FOR_TARGET"; then
8311   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8312 else
8313 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8314 for as_dir in $PATH
8315 do
8316   IFS=$as_save_IFS
8317   test -z "$as_dir" && as_dir=.
8318   for ac_exec_ext in '' $ac_executable_extensions; do
8319   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8320     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8321     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8322     break 2
8323   fi
8324 done
8325 done
8326
8327 fi
8328 fi
8329 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8330 if test -n "$CXX_FOR_TARGET"; then
8331   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8332 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8333 else
8334   echo "$as_me:$LINENO: result: no" >&5
8335 echo "${ECHO_T}no" >&6
8336 fi
8337
8338   done
8339 fi
8340
8341 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8342   for ncn_progname in c++ g++ cxx gxx; do
8343     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8344 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8345     if test -x $with_build_time_tools/${ncn_progname}; then
8346       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8347       echo "$as_me:$LINENO: result: yes" >&5
8348 echo "${ECHO_T}yes" >&6
8349       break
8350     else
8351       echo "$as_me:$LINENO: result: no" >&5
8352 echo "${ECHO_T}no" >&6
8353     fi
8354   done
8355 fi
8356
8357 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8358   for ncn_progname in c++ g++ cxx gxx; do
8359     if test -n "$ncn_target_tool_prefix"; then
8360       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8361 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8362 echo "$as_me:$LINENO: checking for $ac_word" >&5
8363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8364 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8365   echo $ECHO_N "(cached) $ECHO_C" >&6
8366 else
8367   if test -n "$CXX_FOR_TARGET"; then
8368   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8369 else
8370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8371 for as_dir in $PATH
8372 do
8373   IFS=$as_save_IFS
8374   test -z "$as_dir" && as_dir=.
8375   for ac_exec_ext in '' $ac_executable_extensions; do
8376   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8377     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8378     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8379     break 2
8380   fi
8381 done
8382 done
8383
8384 fi
8385 fi
8386 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8387 if test -n "$CXX_FOR_TARGET"; then
8388   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8389 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8390 else
8391   echo "$as_me:$LINENO: result: no" >&5
8392 echo "${ECHO_T}no" >&6
8393 fi
8394
8395     fi
8396     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8397       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8398 set dummy ${ncn_progname}; ac_word=$2
8399 echo "$as_me:$LINENO: checking for $ac_word" >&5
8400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8401 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8402   echo $ECHO_N "(cached) $ECHO_C" >&6
8403 else
8404   if test -n "$CXX_FOR_TARGET"; then
8405   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8406 else
8407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8408 for as_dir in $PATH
8409 do
8410   IFS=$as_save_IFS
8411   test -z "$as_dir" && as_dir=.
8412   for ac_exec_ext in '' $ac_executable_extensions; do
8413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8414     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8416     break 2
8417   fi
8418 done
8419 done
8420
8421 fi
8422 fi
8423 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8424 if test -n "$CXX_FOR_TARGET"; then
8425   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8426 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8427 else
8428   echo "$as_me:$LINENO: result: no" >&5
8429 echo "${ECHO_T}no" >&6
8430 fi
8431
8432     fi
8433     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8434   done
8435 fi
8436
8437 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8438   set dummy c++ g++ cxx gxx
8439   if test $build = $target ; then
8440     CXX_FOR_TARGET="$2"
8441   else
8442     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8443   fi
8444 else
8445   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8446 fi
8447
8448
8449
8450 if test -n "$GCC_FOR_TARGET"; then
8451   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8452 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8453   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8454 fi
8455
8456 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8457   for ncn_progname in gcc; do
8458     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8459 set dummy ${ncn_progname}; ac_word=$2
8460 echo "$as_me:$LINENO: checking for $ac_word" >&5
8461 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8462 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8463   echo $ECHO_N "(cached) $ECHO_C" >&6
8464 else
8465   if test -n "$GCC_FOR_TARGET"; then
8466   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8467 else
8468 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8469 for as_dir in $PATH
8470 do
8471   IFS=$as_save_IFS
8472   test -z "$as_dir" && as_dir=.
8473   for ac_exec_ext in '' $ac_executable_extensions; do
8474   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8475     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8476     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8477     break 2
8478   fi
8479 done
8480 done
8481
8482 fi
8483 fi
8484 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8485 if test -n "$GCC_FOR_TARGET"; then
8486   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8487 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8488 else
8489   echo "$as_me:$LINENO: result: no" >&5
8490 echo "${ECHO_T}no" >&6
8491 fi
8492
8493   done
8494 fi
8495
8496 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8497   for ncn_progname in gcc; do
8498     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8499 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8500     if test -x $with_build_time_tools/${ncn_progname}; then
8501       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8502       echo "$as_me:$LINENO: result: yes" >&5
8503 echo "${ECHO_T}yes" >&6
8504       break
8505     else
8506       echo "$as_me:$LINENO: result: no" >&5
8507 echo "${ECHO_T}no" >&6
8508     fi
8509   done
8510 fi
8511
8512 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8513   for ncn_progname in gcc; do
8514     if test -n "$ncn_target_tool_prefix"; then
8515       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8516 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8517 echo "$as_me:$LINENO: checking for $ac_word" >&5
8518 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8519 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8520   echo $ECHO_N "(cached) $ECHO_C" >&6
8521 else
8522   if test -n "$GCC_FOR_TARGET"; then
8523   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8524 else
8525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8526 for as_dir in $PATH
8527 do
8528   IFS=$as_save_IFS
8529   test -z "$as_dir" && as_dir=.
8530   for ac_exec_ext in '' $ac_executable_extensions; do
8531   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8532     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8533     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8534     break 2
8535   fi
8536 done
8537 done
8538
8539 fi
8540 fi
8541 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8542 if test -n "$GCC_FOR_TARGET"; then
8543   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8544 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8545 else
8546   echo "$as_me:$LINENO: result: no" >&5
8547 echo "${ECHO_T}no" >&6
8548 fi
8549
8550     fi
8551     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8552       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8553 set dummy ${ncn_progname}; ac_word=$2
8554 echo "$as_me:$LINENO: checking for $ac_word" >&5
8555 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8556 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8557   echo $ECHO_N "(cached) $ECHO_C" >&6
8558 else
8559   if test -n "$GCC_FOR_TARGET"; then
8560   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8561 else
8562 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8563 for as_dir in $PATH
8564 do
8565   IFS=$as_save_IFS
8566   test -z "$as_dir" && as_dir=.
8567   for ac_exec_ext in '' $ac_executable_extensions; do
8568   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8569     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8570     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8571     break 2
8572   fi
8573 done
8574 done
8575
8576 fi
8577 fi
8578 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8579 if test -n "$GCC_FOR_TARGET"; then
8580   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8581 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8582 else
8583   echo "$as_me:$LINENO: result: no" >&5
8584 echo "${ECHO_T}no" >&6
8585 fi
8586
8587     fi
8588     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8589   done
8590 fi
8591
8592 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8593   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8594 else
8595   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8596 fi
8597
8598
8599
8600 if test -n "$GCJ_FOR_TARGET"; then
8601   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8602 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8603   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8604 fi
8605
8606 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8607   for ncn_progname in gcj; do
8608     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8609 set dummy ${ncn_progname}; ac_word=$2
8610 echo "$as_me:$LINENO: checking for $ac_word" >&5
8611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8612 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8613   echo $ECHO_N "(cached) $ECHO_C" >&6
8614 else
8615   if test -n "$GCJ_FOR_TARGET"; then
8616   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8617 else
8618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8619 for as_dir in $PATH
8620 do
8621   IFS=$as_save_IFS
8622   test -z "$as_dir" && as_dir=.
8623   for ac_exec_ext in '' $ac_executable_extensions; do
8624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8625     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8627     break 2
8628   fi
8629 done
8630 done
8631
8632 fi
8633 fi
8634 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8635 if test -n "$GCJ_FOR_TARGET"; then
8636   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8637 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8638 else
8639   echo "$as_me:$LINENO: result: no" >&5
8640 echo "${ECHO_T}no" >&6
8641 fi
8642
8643   done
8644 fi
8645
8646 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8647   for ncn_progname in gcj; do
8648     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8649 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8650     if test -x $with_build_time_tools/${ncn_progname}; then
8651       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8652       echo "$as_me:$LINENO: result: yes" >&5
8653 echo "${ECHO_T}yes" >&6
8654       break
8655     else
8656       echo "$as_me:$LINENO: result: no" >&5
8657 echo "${ECHO_T}no" >&6
8658     fi
8659   done
8660 fi
8661
8662 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8663   for ncn_progname in gcj; do
8664     if test -n "$ncn_target_tool_prefix"; then
8665       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8666 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8667 echo "$as_me:$LINENO: checking for $ac_word" >&5
8668 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8669 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8670   echo $ECHO_N "(cached) $ECHO_C" >&6
8671 else
8672   if test -n "$GCJ_FOR_TARGET"; then
8673   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8674 else
8675 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8676 for as_dir in $PATH
8677 do
8678   IFS=$as_save_IFS
8679   test -z "$as_dir" && as_dir=.
8680   for ac_exec_ext in '' $ac_executable_extensions; do
8681   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8682     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8683     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8684     break 2
8685   fi
8686 done
8687 done
8688
8689 fi
8690 fi
8691 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8692 if test -n "$GCJ_FOR_TARGET"; then
8693   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8694 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8695 else
8696   echo "$as_me:$LINENO: result: no" >&5
8697 echo "${ECHO_T}no" >&6
8698 fi
8699
8700     fi
8701     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8702       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8703 set dummy ${ncn_progname}; ac_word=$2
8704 echo "$as_me:$LINENO: checking for $ac_word" >&5
8705 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8706 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8707   echo $ECHO_N "(cached) $ECHO_C" >&6
8708 else
8709   if test -n "$GCJ_FOR_TARGET"; then
8710   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8711 else
8712 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8713 for as_dir in $PATH
8714 do
8715   IFS=$as_save_IFS
8716   test -z "$as_dir" && as_dir=.
8717   for ac_exec_ext in '' $ac_executable_extensions; do
8718   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8719     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8720     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8721     break 2
8722   fi
8723 done
8724 done
8725
8726 fi
8727 fi
8728 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8729 if test -n "$GCJ_FOR_TARGET"; then
8730   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8731 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8732 else
8733   echo "$as_me:$LINENO: result: no" >&5
8734 echo "${ECHO_T}no" >&6
8735 fi
8736
8737     fi
8738     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8739   done
8740 fi
8741
8742 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8743   set dummy gcj
8744   if test $build = $target ; then
8745     GCJ_FOR_TARGET="$2"
8746   else
8747     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8748   fi
8749 else
8750   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8751 fi
8752
8753
8754
8755 if test -n "$GFORTRAN_FOR_TARGET"; then
8756   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8757 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8758   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8759 fi
8760
8761 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8762   for ncn_progname in gfortran; do
8763     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8764 set dummy ${ncn_progname}; ac_word=$2
8765 echo "$as_me:$LINENO: checking for $ac_word" >&5
8766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8767 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8768   echo $ECHO_N "(cached) $ECHO_C" >&6
8769 else
8770   if test -n "$GFORTRAN_FOR_TARGET"; then
8771   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8772 else
8773 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8774 for as_dir in $PATH
8775 do
8776   IFS=$as_save_IFS
8777   test -z "$as_dir" && as_dir=.
8778   for ac_exec_ext in '' $ac_executable_extensions; do
8779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8780     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8782     break 2
8783   fi
8784 done
8785 done
8786
8787 fi
8788 fi
8789 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8790 if test -n "$GFORTRAN_FOR_TARGET"; then
8791   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8792 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8793 else
8794   echo "$as_me:$LINENO: result: no" >&5
8795 echo "${ECHO_T}no" >&6
8796 fi
8797
8798   done
8799 fi
8800
8801 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8802   for ncn_progname in gfortran; do
8803     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8804 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8805     if test -x $with_build_time_tools/${ncn_progname}; then
8806       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8807       echo "$as_me:$LINENO: result: yes" >&5
8808 echo "${ECHO_T}yes" >&6
8809       break
8810     else
8811       echo "$as_me:$LINENO: result: no" >&5
8812 echo "${ECHO_T}no" >&6
8813     fi
8814   done
8815 fi
8816
8817 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8818   for ncn_progname in gfortran; do
8819     if test -n "$ncn_target_tool_prefix"; then
8820       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8821 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8822 echo "$as_me:$LINENO: checking for $ac_word" >&5
8823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8824 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8825   echo $ECHO_N "(cached) $ECHO_C" >&6
8826 else
8827   if test -n "$GFORTRAN_FOR_TARGET"; then
8828   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8829 else
8830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8831 for as_dir in $PATH
8832 do
8833   IFS=$as_save_IFS
8834   test -z "$as_dir" && as_dir=.
8835   for ac_exec_ext in '' $ac_executable_extensions; do
8836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8837     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8839     break 2
8840   fi
8841 done
8842 done
8843
8844 fi
8845 fi
8846 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8847 if test -n "$GFORTRAN_FOR_TARGET"; then
8848   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8849 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8850 else
8851   echo "$as_me:$LINENO: result: no" >&5
8852 echo "${ECHO_T}no" >&6
8853 fi
8854
8855     fi
8856     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8857       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8858 set dummy ${ncn_progname}; ac_word=$2
8859 echo "$as_me:$LINENO: checking for $ac_word" >&5
8860 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8861 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8862   echo $ECHO_N "(cached) $ECHO_C" >&6
8863 else
8864   if test -n "$GFORTRAN_FOR_TARGET"; then
8865   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8866 else
8867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8868 for as_dir in $PATH
8869 do
8870   IFS=$as_save_IFS
8871   test -z "$as_dir" && as_dir=.
8872   for ac_exec_ext in '' $ac_executable_extensions; do
8873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8874     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8876     break 2
8877   fi
8878 done
8879 done
8880
8881 fi
8882 fi
8883 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8884 if test -n "$GFORTRAN_FOR_TARGET"; then
8885   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8886 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8887 else
8888   echo "$as_me:$LINENO: result: no" >&5
8889 echo "${ECHO_T}no" >&6
8890 fi
8891
8892     fi
8893     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8894   done
8895 fi
8896
8897 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8898   set dummy gfortran
8899   if test $build = $target ; then
8900     GFORTRAN_FOR_TARGET="$2"
8901   else
8902     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8903   fi
8904 else
8905   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8906 fi
8907
8908
8909
8910 cat > conftest.c << \EOF
8911 #ifdef __GNUC__
8912   gcc_yay;
8913 #endif
8914 EOF
8915 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8916   have_gcc_for_target=yes
8917 else
8918   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8919   have_gcc_for_target=no
8920 fi
8921 rm conftest.c
8922
8923
8924
8925
8926 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8927   if test -n "$with_build_time_tools"; then
8928     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8929 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8930     if test -x $with_build_time_tools/ar; then
8931       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8932       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8933       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8934 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8935     else
8936       echo "$as_me:$LINENO: result: no" >&5
8937 echo "${ECHO_T}no" >&6
8938     fi
8939   elif test $build != $host && test $have_gcc_for_target = yes; then
8940     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8941     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8942     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8943   fi
8944 fi
8945 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8946   # Extract the first word of "ar", so it can be a program name with args.
8947 set dummy ar; ac_word=$2
8948 echo "$as_me:$LINENO: checking for $ac_word" >&5
8949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8950 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8951   echo $ECHO_N "(cached) $ECHO_C" >&6
8952 else
8953   case $AR_FOR_TARGET in
8954   [\\/]* | ?:[\\/]*)
8955   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8956   ;;
8957   *)
8958   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8959 for as_dir in $gcc_cv_tool_dirs
8960 do
8961   IFS=$as_save_IFS
8962   test -z "$as_dir" && as_dir=.
8963   for ac_exec_ext in '' $ac_executable_extensions; do
8964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8965     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8967     break 2
8968   fi
8969 done
8970 done
8971
8972   ;;
8973 esac
8974 fi
8975 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8976
8977 if test -n "$AR_FOR_TARGET"; then
8978   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8979 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8980 else
8981   echo "$as_me:$LINENO: result: no" >&5
8982 echo "${ECHO_T}no" >&6
8983 fi
8984
8985 fi
8986 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8987
8988
8989 if test -n "$AR_FOR_TARGET"; then
8990   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8991 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8992   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8993 fi
8994
8995 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8996   for ncn_progname in ar; do
8997     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8998 set dummy ${ncn_progname}; ac_word=$2
8999 echo "$as_me:$LINENO: checking for $ac_word" >&5
9000 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9001 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9002   echo $ECHO_N "(cached) $ECHO_C" >&6
9003 else
9004   if test -n "$AR_FOR_TARGET"; then
9005   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9006 else
9007 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9008 for as_dir in $PATH
9009 do
9010   IFS=$as_save_IFS
9011   test -z "$as_dir" && as_dir=.
9012   for ac_exec_ext in '' $ac_executable_extensions; do
9013   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9014     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9015     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9016     break 2
9017   fi
9018 done
9019 done
9020
9021 fi
9022 fi
9023 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9024 if test -n "$AR_FOR_TARGET"; then
9025   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9026 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9027 else
9028   echo "$as_me:$LINENO: result: no" >&5
9029 echo "${ECHO_T}no" >&6
9030 fi
9031
9032   done
9033 fi
9034
9035 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9036   for ncn_progname in ar; do
9037     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9038 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9039     if test -x $with_build_time_tools/${ncn_progname}; then
9040       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9041       echo "$as_me:$LINENO: result: yes" >&5
9042 echo "${ECHO_T}yes" >&6
9043       break
9044     else
9045       echo "$as_me:$LINENO: result: no" >&5
9046 echo "${ECHO_T}no" >&6
9047     fi
9048   done
9049 fi
9050
9051 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9052   for ncn_progname in ar; do
9053     if test -n "$ncn_target_tool_prefix"; then
9054       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9055 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9056 echo "$as_me:$LINENO: checking for $ac_word" >&5
9057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9058 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9059   echo $ECHO_N "(cached) $ECHO_C" >&6
9060 else
9061   if test -n "$AR_FOR_TARGET"; then
9062   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9063 else
9064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9065 for as_dir in $PATH
9066 do
9067   IFS=$as_save_IFS
9068   test -z "$as_dir" && as_dir=.
9069   for ac_exec_ext in '' $ac_executable_extensions; do
9070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9071     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9073     break 2
9074   fi
9075 done
9076 done
9077
9078 fi
9079 fi
9080 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9081 if test -n "$AR_FOR_TARGET"; then
9082   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9083 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9084 else
9085   echo "$as_me:$LINENO: result: no" >&5
9086 echo "${ECHO_T}no" >&6
9087 fi
9088
9089     fi
9090     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9091       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9092 set dummy ${ncn_progname}; ac_word=$2
9093 echo "$as_me:$LINENO: checking for $ac_word" >&5
9094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9095 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9096   echo $ECHO_N "(cached) $ECHO_C" >&6
9097 else
9098   if test -n "$AR_FOR_TARGET"; then
9099   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9100 else
9101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9102 for as_dir in $PATH
9103 do
9104   IFS=$as_save_IFS
9105   test -z "$as_dir" && as_dir=.
9106   for ac_exec_ext in '' $ac_executable_extensions; do
9107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9108     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9110     break 2
9111   fi
9112 done
9113 done
9114
9115 fi
9116 fi
9117 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9118 if test -n "$AR_FOR_TARGET"; then
9119   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9120 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9121 else
9122   echo "$as_me:$LINENO: result: no" >&5
9123 echo "${ECHO_T}no" >&6
9124 fi
9125
9126     fi
9127     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9128   done
9129 fi
9130
9131 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9132   set dummy ar
9133   if test $build = $target ; then
9134     AR_FOR_TARGET="$2"
9135   else
9136     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9137   fi
9138 else
9139   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9140 fi
9141
9142 else
9143   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9144 fi
9145
9146
9147
9148
9149 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9150   if test -n "$with_build_time_tools"; then
9151     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9152 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9153     if test -x $with_build_time_tools/as; then
9154       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9155       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9156       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9157 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9158     else
9159       echo "$as_me:$LINENO: result: no" >&5
9160 echo "${ECHO_T}no" >&6
9161     fi
9162   elif test $build != $host && test $have_gcc_for_target = yes; then
9163     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9164     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9165     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9166   fi
9167 fi
9168 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9169   # Extract the first word of "as", so it can be a program name with args.
9170 set dummy as; ac_word=$2
9171 echo "$as_me:$LINENO: checking for $ac_word" >&5
9172 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9173 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9174   echo $ECHO_N "(cached) $ECHO_C" >&6
9175 else
9176   case $AS_FOR_TARGET in
9177   [\\/]* | ?:[\\/]*)
9178   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9179   ;;
9180   *)
9181   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9182 for as_dir in $gcc_cv_tool_dirs
9183 do
9184   IFS=$as_save_IFS
9185   test -z "$as_dir" && as_dir=.
9186   for ac_exec_ext in '' $ac_executable_extensions; do
9187   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9188     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9189     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9190     break 2
9191   fi
9192 done
9193 done
9194
9195   ;;
9196 esac
9197 fi
9198 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9199
9200 if test -n "$AS_FOR_TARGET"; then
9201   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9202 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9203 else
9204   echo "$as_me:$LINENO: result: no" >&5
9205 echo "${ECHO_T}no" >&6
9206 fi
9207
9208 fi
9209 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9210
9211
9212 if test -n "$AS_FOR_TARGET"; then
9213   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9214 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9215   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9216 fi
9217
9218 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9219   for ncn_progname in as; do
9220     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9221 set dummy ${ncn_progname}; ac_word=$2
9222 echo "$as_me:$LINENO: checking for $ac_word" >&5
9223 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9224 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9225   echo $ECHO_N "(cached) $ECHO_C" >&6
9226 else
9227   if test -n "$AS_FOR_TARGET"; then
9228   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9229 else
9230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9231 for as_dir in $PATH
9232 do
9233   IFS=$as_save_IFS
9234   test -z "$as_dir" && as_dir=.
9235   for ac_exec_ext in '' $ac_executable_extensions; do
9236   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9237     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9238     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9239     break 2
9240   fi
9241 done
9242 done
9243
9244 fi
9245 fi
9246 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9247 if test -n "$AS_FOR_TARGET"; then
9248   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9249 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9250 else
9251   echo "$as_me:$LINENO: result: no" >&5
9252 echo "${ECHO_T}no" >&6
9253 fi
9254
9255   done
9256 fi
9257
9258 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9259   for ncn_progname in as; do
9260     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9261 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9262     if test -x $with_build_time_tools/${ncn_progname}; then
9263       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9264       echo "$as_me:$LINENO: result: yes" >&5
9265 echo "${ECHO_T}yes" >&6
9266       break
9267     else
9268       echo "$as_me:$LINENO: result: no" >&5
9269 echo "${ECHO_T}no" >&6
9270     fi
9271   done
9272 fi
9273
9274 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9275   for ncn_progname in as; do
9276     if test -n "$ncn_target_tool_prefix"; then
9277       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9278 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9279 echo "$as_me:$LINENO: checking for $ac_word" >&5
9280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9281 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9282   echo $ECHO_N "(cached) $ECHO_C" >&6
9283 else
9284   if test -n "$AS_FOR_TARGET"; then
9285   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9286 else
9287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9288 for as_dir in $PATH
9289 do
9290   IFS=$as_save_IFS
9291   test -z "$as_dir" && as_dir=.
9292   for ac_exec_ext in '' $ac_executable_extensions; do
9293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9294     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9296     break 2
9297   fi
9298 done
9299 done
9300
9301 fi
9302 fi
9303 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9304 if test -n "$AS_FOR_TARGET"; then
9305   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9306 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9307 else
9308   echo "$as_me:$LINENO: result: no" >&5
9309 echo "${ECHO_T}no" >&6
9310 fi
9311
9312     fi
9313     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9314       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9315 set dummy ${ncn_progname}; ac_word=$2
9316 echo "$as_me:$LINENO: checking for $ac_word" >&5
9317 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9318 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9319   echo $ECHO_N "(cached) $ECHO_C" >&6
9320 else
9321   if test -n "$AS_FOR_TARGET"; then
9322   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9323 else
9324 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9325 for as_dir in $PATH
9326 do
9327   IFS=$as_save_IFS
9328   test -z "$as_dir" && as_dir=.
9329   for ac_exec_ext in '' $ac_executable_extensions; do
9330   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9331     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9332     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9333     break 2
9334   fi
9335 done
9336 done
9337
9338 fi
9339 fi
9340 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9341 if test -n "$AS_FOR_TARGET"; then
9342   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9343 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9344 else
9345   echo "$as_me:$LINENO: result: no" >&5
9346 echo "${ECHO_T}no" >&6
9347 fi
9348
9349     fi
9350     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9351   done
9352 fi
9353
9354 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9355   set dummy as
9356   if test $build = $target ; then
9357     AS_FOR_TARGET="$2"
9358   else
9359     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9360   fi
9361 else
9362   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9363 fi
9364
9365 else
9366   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9367 fi
9368
9369
9370
9371
9372 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9373   if test -n "$with_build_time_tools"; then
9374     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9375 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9376     if test -x $with_build_time_tools/dlltool; then
9377       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9378       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9379       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9380 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9381     else
9382       echo "$as_me:$LINENO: result: no" >&5
9383 echo "${ECHO_T}no" >&6
9384     fi
9385   elif test $build != $host && test $have_gcc_for_target = yes; then
9386     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9387     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9388     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9389   fi
9390 fi
9391 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9392   # Extract the first word of "dlltool", so it can be a program name with args.
9393 set dummy dlltool; ac_word=$2
9394 echo "$as_me:$LINENO: checking for $ac_word" >&5
9395 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9396 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9397   echo $ECHO_N "(cached) $ECHO_C" >&6
9398 else
9399   case $DLLTOOL_FOR_TARGET in
9400   [\\/]* | ?:[\\/]*)
9401   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9402   ;;
9403   *)
9404   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9405 for as_dir in $gcc_cv_tool_dirs
9406 do
9407   IFS=$as_save_IFS
9408   test -z "$as_dir" && as_dir=.
9409   for ac_exec_ext in '' $ac_executable_extensions; do
9410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9411     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9413     break 2
9414   fi
9415 done
9416 done
9417
9418   ;;
9419 esac
9420 fi
9421 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9422
9423 if test -n "$DLLTOOL_FOR_TARGET"; then
9424   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9425 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9426 else
9427   echo "$as_me:$LINENO: result: no" >&5
9428 echo "${ECHO_T}no" >&6
9429 fi
9430
9431 fi
9432 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9433
9434
9435 if test -n "$DLLTOOL_FOR_TARGET"; then
9436   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9437 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9438   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9439 fi
9440
9441 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9442   for ncn_progname in dlltool; do
9443     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9444 set dummy ${ncn_progname}; ac_word=$2
9445 echo "$as_me:$LINENO: checking for $ac_word" >&5
9446 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9447 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9448   echo $ECHO_N "(cached) $ECHO_C" >&6
9449 else
9450   if test -n "$DLLTOOL_FOR_TARGET"; then
9451   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9452 else
9453 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9454 for as_dir in $PATH
9455 do
9456   IFS=$as_save_IFS
9457   test -z "$as_dir" && as_dir=.
9458   for ac_exec_ext in '' $ac_executable_extensions; do
9459   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9460     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9461     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9462     break 2
9463   fi
9464 done
9465 done
9466
9467 fi
9468 fi
9469 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9470 if test -n "$DLLTOOL_FOR_TARGET"; then
9471   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9472 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9473 else
9474   echo "$as_me:$LINENO: result: no" >&5
9475 echo "${ECHO_T}no" >&6
9476 fi
9477
9478   done
9479 fi
9480
9481 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9482   for ncn_progname in dlltool; do
9483     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9484 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9485     if test -x $with_build_time_tools/${ncn_progname}; then
9486       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9487       echo "$as_me:$LINENO: result: yes" >&5
9488 echo "${ECHO_T}yes" >&6
9489       break
9490     else
9491       echo "$as_me:$LINENO: result: no" >&5
9492 echo "${ECHO_T}no" >&6
9493     fi
9494   done
9495 fi
9496
9497 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9498   for ncn_progname in dlltool; do
9499     if test -n "$ncn_target_tool_prefix"; then
9500       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9501 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9502 echo "$as_me:$LINENO: checking for $ac_word" >&5
9503 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9504 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9505   echo $ECHO_N "(cached) $ECHO_C" >&6
9506 else
9507   if test -n "$DLLTOOL_FOR_TARGET"; then
9508   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9509 else
9510 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9511 for as_dir in $PATH
9512 do
9513   IFS=$as_save_IFS
9514   test -z "$as_dir" && as_dir=.
9515   for ac_exec_ext in '' $ac_executable_extensions; do
9516   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9517     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9518     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9519     break 2
9520   fi
9521 done
9522 done
9523
9524 fi
9525 fi
9526 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9527 if test -n "$DLLTOOL_FOR_TARGET"; then
9528   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9529 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9530 else
9531   echo "$as_me:$LINENO: result: no" >&5
9532 echo "${ECHO_T}no" >&6
9533 fi
9534
9535     fi
9536     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9537       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9538 set dummy ${ncn_progname}; ac_word=$2
9539 echo "$as_me:$LINENO: checking for $ac_word" >&5
9540 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9541 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9542   echo $ECHO_N "(cached) $ECHO_C" >&6
9543 else
9544   if test -n "$DLLTOOL_FOR_TARGET"; then
9545   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9546 else
9547 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9548 for as_dir in $PATH
9549 do
9550   IFS=$as_save_IFS
9551   test -z "$as_dir" && as_dir=.
9552   for ac_exec_ext in '' $ac_executable_extensions; do
9553   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9554     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9555     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9556     break 2
9557   fi
9558 done
9559 done
9560
9561 fi
9562 fi
9563 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9564 if test -n "$DLLTOOL_FOR_TARGET"; then
9565   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9566 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9567 else
9568   echo "$as_me:$LINENO: result: no" >&5
9569 echo "${ECHO_T}no" >&6
9570 fi
9571
9572     fi
9573     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9574   done
9575 fi
9576
9577 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9578   set dummy dlltool
9579   if test $build = $target ; then
9580     DLLTOOL_FOR_TARGET="$2"
9581   else
9582     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9583   fi
9584 else
9585   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9586 fi
9587
9588 else
9589   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9590 fi
9591
9592
9593
9594
9595 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9596   if test -n "$with_build_time_tools"; then
9597     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9598 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9599     if test -x $with_build_time_tools/ld; then
9600       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9601       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9602       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9603 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9604     else
9605       echo "$as_me:$LINENO: result: no" >&5
9606 echo "${ECHO_T}no" >&6
9607     fi
9608   elif test $build != $host && test $have_gcc_for_target = yes; then
9609     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9610     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9611     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9612   fi
9613 fi
9614 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9615   # Extract the first word of "ld", so it can be a program name with args.
9616 set dummy ld; ac_word=$2
9617 echo "$as_me:$LINENO: checking for $ac_word" >&5
9618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9619 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9620   echo $ECHO_N "(cached) $ECHO_C" >&6
9621 else
9622   case $LD_FOR_TARGET in
9623   [\\/]* | ?:[\\/]*)
9624   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9625   ;;
9626   *)
9627   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9628 for as_dir in $gcc_cv_tool_dirs
9629 do
9630   IFS=$as_save_IFS
9631   test -z "$as_dir" && as_dir=.
9632   for ac_exec_ext in '' $ac_executable_extensions; do
9633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9634     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9636     break 2
9637   fi
9638 done
9639 done
9640
9641   ;;
9642 esac
9643 fi
9644 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9645
9646 if test -n "$LD_FOR_TARGET"; then
9647   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9648 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9649 else
9650   echo "$as_me:$LINENO: result: no" >&5
9651 echo "${ECHO_T}no" >&6
9652 fi
9653
9654 fi
9655 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9656
9657
9658 if test -n "$LD_FOR_TARGET"; then
9659   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9660 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9661   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9662 fi
9663
9664 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9665   for ncn_progname in ld; do
9666     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9667 set dummy ${ncn_progname}; ac_word=$2
9668 echo "$as_me:$LINENO: checking for $ac_word" >&5
9669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9670 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9671   echo $ECHO_N "(cached) $ECHO_C" >&6
9672 else
9673   if test -n "$LD_FOR_TARGET"; then
9674   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9675 else
9676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9677 for as_dir in $PATH
9678 do
9679   IFS=$as_save_IFS
9680   test -z "$as_dir" && as_dir=.
9681   for ac_exec_ext in '' $ac_executable_extensions; do
9682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9683     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9685     break 2
9686   fi
9687 done
9688 done
9689
9690 fi
9691 fi
9692 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9693 if test -n "$LD_FOR_TARGET"; then
9694   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9695 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9696 else
9697   echo "$as_me:$LINENO: result: no" >&5
9698 echo "${ECHO_T}no" >&6
9699 fi
9700
9701   done
9702 fi
9703
9704 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9705   for ncn_progname in ld; do
9706     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9707 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9708     if test -x $with_build_time_tools/${ncn_progname}; then
9709       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9710       echo "$as_me:$LINENO: result: yes" >&5
9711 echo "${ECHO_T}yes" >&6
9712       break
9713     else
9714       echo "$as_me:$LINENO: result: no" >&5
9715 echo "${ECHO_T}no" >&6
9716     fi
9717   done
9718 fi
9719
9720 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9721   for ncn_progname in ld; do
9722     if test -n "$ncn_target_tool_prefix"; then
9723       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9724 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9725 echo "$as_me:$LINENO: checking for $ac_word" >&5
9726 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9727 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9728   echo $ECHO_N "(cached) $ECHO_C" >&6
9729 else
9730   if test -n "$LD_FOR_TARGET"; then
9731   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9732 else
9733 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9734 for as_dir in $PATH
9735 do
9736   IFS=$as_save_IFS
9737   test -z "$as_dir" && as_dir=.
9738   for ac_exec_ext in '' $ac_executable_extensions; do
9739   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9740     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9741     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9742     break 2
9743   fi
9744 done
9745 done
9746
9747 fi
9748 fi
9749 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9750 if test -n "$LD_FOR_TARGET"; then
9751   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9752 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9753 else
9754   echo "$as_me:$LINENO: result: no" >&5
9755 echo "${ECHO_T}no" >&6
9756 fi
9757
9758     fi
9759     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9760       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9761 set dummy ${ncn_progname}; ac_word=$2
9762 echo "$as_me:$LINENO: checking for $ac_word" >&5
9763 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9764 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9765   echo $ECHO_N "(cached) $ECHO_C" >&6
9766 else
9767   if test -n "$LD_FOR_TARGET"; then
9768   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9769 else
9770 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9771 for as_dir in $PATH
9772 do
9773   IFS=$as_save_IFS
9774   test -z "$as_dir" && as_dir=.
9775   for ac_exec_ext in '' $ac_executable_extensions; do
9776   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9777     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9778     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9779     break 2
9780   fi
9781 done
9782 done
9783
9784 fi
9785 fi
9786 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9787 if test -n "$LD_FOR_TARGET"; then
9788   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9789 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9790 else
9791   echo "$as_me:$LINENO: result: no" >&5
9792 echo "${ECHO_T}no" >&6
9793 fi
9794
9795     fi
9796     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9797   done
9798 fi
9799
9800 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9801   set dummy ld
9802   if test $build = $target ; then
9803     LD_FOR_TARGET="$2"
9804   else
9805     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9806   fi
9807 else
9808   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9809 fi
9810
9811 else
9812   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9813 fi
9814
9815
9816
9817
9818 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9819   if test -n "$with_build_time_tools"; then
9820     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9821 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9822     if test -x $with_build_time_tools/lipo; then
9823       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9824       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9825       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9826 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9827     else
9828       echo "$as_me:$LINENO: result: no" >&5
9829 echo "${ECHO_T}no" >&6
9830     fi
9831   elif test $build != $host && test $have_gcc_for_target = yes; then
9832     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9833     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9834     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9835   fi
9836 fi
9837 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9838   # Extract the first word of "lipo", so it can be a program name with args.
9839 set dummy lipo; ac_word=$2
9840 echo "$as_me:$LINENO: checking for $ac_word" >&5
9841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9842 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9843   echo $ECHO_N "(cached) $ECHO_C" >&6
9844 else
9845   case $LIPO_FOR_TARGET in
9846   [\\/]* | ?:[\\/]*)
9847   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9848   ;;
9849   *)
9850   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9851 for as_dir in $gcc_cv_tool_dirs
9852 do
9853   IFS=$as_save_IFS
9854   test -z "$as_dir" && as_dir=.
9855   for ac_exec_ext in '' $ac_executable_extensions; do
9856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9857     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9859     break 2
9860   fi
9861 done
9862 done
9863
9864   ;;
9865 esac
9866 fi
9867 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9868
9869 if test -n "$LIPO_FOR_TARGET"; then
9870   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9871 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9872 else
9873   echo "$as_me:$LINENO: result: no" >&5
9874 echo "${ECHO_T}no" >&6
9875 fi
9876
9877 fi
9878 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9879
9880
9881 if test -n "$LIPO_FOR_TARGET"; then
9882   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9883 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9884   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9885 fi
9886
9887 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9888   for ncn_progname in lipo; do
9889     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9890 set dummy ${ncn_progname}; ac_word=$2
9891 echo "$as_me:$LINENO: checking for $ac_word" >&5
9892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9893 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9894   echo $ECHO_N "(cached) $ECHO_C" >&6
9895 else
9896   if test -n "$LIPO_FOR_TARGET"; then
9897   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9898 else
9899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9900 for as_dir in $PATH
9901 do
9902   IFS=$as_save_IFS
9903   test -z "$as_dir" && as_dir=.
9904   for ac_exec_ext in '' $ac_executable_extensions; do
9905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9906     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9908     break 2
9909   fi
9910 done
9911 done
9912
9913 fi
9914 fi
9915 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9916 if test -n "$LIPO_FOR_TARGET"; then
9917   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9918 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9919 else
9920   echo "$as_me:$LINENO: result: no" >&5
9921 echo "${ECHO_T}no" >&6
9922 fi
9923
9924   done
9925 fi
9926
9927 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9928   for ncn_progname in lipo; do
9929     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9930 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9931     if test -x $with_build_time_tools/${ncn_progname}; then
9932       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9933       echo "$as_me:$LINENO: result: yes" >&5
9934 echo "${ECHO_T}yes" >&6
9935       break
9936     else
9937       echo "$as_me:$LINENO: result: no" >&5
9938 echo "${ECHO_T}no" >&6
9939     fi
9940   done
9941 fi
9942
9943 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9944   for ncn_progname in lipo; do
9945     if test -n "$ncn_target_tool_prefix"; then
9946       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9947 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9948 echo "$as_me:$LINENO: checking for $ac_word" >&5
9949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9950 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9951   echo $ECHO_N "(cached) $ECHO_C" >&6
9952 else
9953   if test -n "$LIPO_FOR_TARGET"; then
9954   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9955 else
9956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9957 for as_dir in $PATH
9958 do
9959   IFS=$as_save_IFS
9960   test -z "$as_dir" && as_dir=.
9961   for ac_exec_ext in '' $ac_executable_extensions; do
9962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9963     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9965     break 2
9966   fi
9967 done
9968 done
9969
9970 fi
9971 fi
9972 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9973 if test -n "$LIPO_FOR_TARGET"; then
9974   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9975 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9976 else
9977   echo "$as_me:$LINENO: result: no" >&5
9978 echo "${ECHO_T}no" >&6
9979 fi
9980
9981     fi
9982     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9983       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9984 set dummy ${ncn_progname}; ac_word=$2
9985 echo "$as_me:$LINENO: checking for $ac_word" >&5
9986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9987 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9988   echo $ECHO_N "(cached) $ECHO_C" >&6
9989 else
9990   if test -n "$LIPO_FOR_TARGET"; then
9991   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9992 else
9993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9994 for as_dir in $PATH
9995 do
9996   IFS=$as_save_IFS
9997   test -z "$as_dir" && as_dir=.
9998   for ac_exec_ext in '' $ac_executable_extensions; do
9999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10000     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10002     break 2
10003   fi
10004 done
10005 done
10006
10007 fi
10008 fi
10009 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10010 if test -n "$LIPO_FOR_TARGET"; then
10011   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10012 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10013 else
10014   echo "$as_me:$LINENO: result: no" >&5
10015 echo "${ECHO_T}no" >&6
10016 fi
10017
10018     fi
10019     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10020   done
10021 fi
10022
10023 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10024   set dummy lipo
10025   if test $build = $target ; then
10026     LIPO_FOR_TARGET="$2"
10027   else
10028     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10029   fi
10030 else
10031   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10032 fi
10033
10034 else
10035   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10036 fi
10037
10038
10039
10040
10041 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10042   if test -n "$with_build_time_tools"; then
10043     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10044 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10045     if test -x $with_build_time_tools/nm; then
10046       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10047       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10048       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10049 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10050     else
10051       echo "$as_me:$LINENO: result: no" >&5
10052 echo "${ECHO_T}no" >&6
10053     fi
10054   elif test $build != $host && test $have_gcc_for_target = yes; then
10055     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10056     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10057     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10058   fi
10059 fi
10060 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10061   # Extract the first word of "nm", so it can be a program name with args.
10062 set dummy nm; ac_word=$2
10063 echo "$as_me:$LINENO: checking for $ac_word" >&5
10064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10065 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10066   echo $ECHO_N "(cached) $ECHO_C" >&6
10067 else
10068   case $NM_FOR_TARGET in
10069   [\\/]* | ?:[\\/]*)
10070   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10071   ;;
10072   *)
10073   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10074 for as_dir in $gcc_cv_tool_dirs
10075 do
10076   IFS=$as_save_IFS
10077   test -z "$as_dir" && as_dir=.
10078   for ac_exec_ext in '' $ac_executable_extensions; do
10079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10080     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10082     break 2
10083   fi
10084 done
10085 done
10086
10087   ;;
10088 esac
10089 fi
10090 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10091
10092 if test -n "$NM_FOR_TARGET"; then
10093   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10094 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10095 else
10096   echo "$as_me:$LINENO: result: no" >&5
10097 echo "${ECHO_T}no" >&6
10098 fi
10099
10100 fi
10101 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10102
10103
10104 if test -n "$NM_FOR_TARGET"; then
10105   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10106 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10107   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10108 fi
10109
10110 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10111   for ncn_progname in nm; do
10112     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10113 set dummy ${ncn_progname}; ac_word=$2
10114 echo "$as_me:$LINENO: checking for $ac_word" >&5
10115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10116 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10117   echo $ECHO_N "(cached) $ECHO_C" >&6
10118 else
10119   if test -n "$NM_FOR_TARGET"; then
10120   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10121 else
10122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10123 for as_dir in $PATH
10124 do
10125   IFS=$as_save_IFS
10126   test -z "$as_dir" && as_dir=.
10127   for ac_exec_ext in '' $ac_executable_extensions; do
10128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10129     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10131     break 2
10132   fi
10133 done
10134 done
10135
10136 fi
10137 fi
10138 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10139 if test -n "$NM_FOR_TARGET"; then
10140   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10141 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10142 else
10143   echo "$as_me:$LINENO: result: no" >&5
10144 echo "${ECHO_T}no" >&6
10145 fi
10146
10147   done
10148 fi
10149
10150 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10151   for ncn_progname in nm; do
10152     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10153 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10154     if test -x $with_build_time_tools/${ncn_progname}; then
10155       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10156       echo "$as_me:$LINENO: result: yes" >&5
10157 echo "${ECHO_T}yes" >&6
10158       break
10159     else
10160       echo "$as_me:$LINENO: result: no" >&5
10161 echo "${ECHO_T}no" >&6
10162     fi
10163   done
10164 fi
10165
10166 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10167   for ncn_progname in nm; do
10168     if test -n "$ncn_target_tool_prefix"; then
10169       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10170 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10171 echo "$as_me:$LINENO: checking for $ac_word" >&5
10172 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10173 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10174   echo $ECHO_N "(cached) $ECHO_C" >&6
10175 else
10176   if test -n "$NM_FOR_TARGET"; then
10177   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10178 else
10179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10180 for as_dir in $PATH
10181 do
10182   IFS=$as_save_IFS
10183   test -z "$as_dir" && as_dir=.
10184   for ac_exec_ext in '' $ac_executable_extensions; do
10185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10186     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10187     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10188     break 2
10189   fi
10190 done
10191 done
10192
10193 fi
10194 fi
10195 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10196 if test -n "$NM_FOR_TARGET"; then
10197   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10198 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10199 else
10200   echo "$as_me:$LINENO: result: no" >&5
10201 echo "${ECHO_T}no" >&6
10202 fi
10203
10204     fi
10205     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10206       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10207 set dummy ${ncn_progname}; ac_word=$2
10208 echo "$as_me:$LINENO: checking for $ac_word" >&5
10209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10210 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10211   echo $ECHO_N "(cached) $ECHO_C" >&6
10212 else
10213   if test -n "$NM_FOR_TARGET"; then
10214   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10215 else
10216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10217 for as_dir in $PATH
10218 do
10219   IFS=$as_save_IFS
10220   test -z "$as_dir" && as_dir=.
10221   for ac_exec_ext in '' $ac_executable_extensions; do
10222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10223     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10225     break 2
10226   fi
10227 done
10228 done
10229
10230 fi
10231 fi
10232 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10233 if test -n "$NM_FOR_TARGET"; then
10234   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10235 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10236 else
10237   echo "$as_me:$LINENO: result: no" >&5
10238 echo "${ECHO_T}no" >&6
10239 fi
10240
10241     fi
10242     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10243   done
10244 fi
10245
10246 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10247   set dummy nm
10248   if test $build = $target ; then
10249     NM_FOR_TARGET="$2"
10250   else
10251     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10252   fi
10253 else
10254   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10255 fi
10256
10257 else
10258   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10259 fi
10260
10261
10262
10263
10264 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10265   if test -n "$with_build_time_tools"; then
10266     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10267 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10268     if test -x $with_build_time_tools/objdump; then
10269       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10270       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10271       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10272 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10273     else
10274       echo "$as_me:$LINENO: result: no" >&5
10275 echo "${ECHO_T}no" >&6
10276     fi
10277   elif test $build != $host && test $have_gcc_for_target = yes; then
10278     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10279     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10280     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10281   fi
10282 fi
10283 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10284   # Extract the first word of "objdump", so it can be a program name with args.
10285 set dummy objdump; ac_word=$2
10286 echo "$as_me:$LINENO: checking for $ac_word" >&5
10287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10288 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10289   echo $ECHO_N "(cached) $ECHO_C" >&6
10290 else
10291   case $OBJDUMP_FOR_TARGET in
10292   [\\/]* | ?:[\\/]*)
10293   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10294   ;;
10295   *)
10296   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10297 for as_dir in $gcc_cv_tool_dirs
10298 do
10299   IFS=$as_save_IFS
10300   test -z "$as_dir" && as_dir=.
10301   for ac_exec_ext in '' $ac_executable_extensions; do
10302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10303     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10305     break 2
10306   fi
10307 done
10308 done
10309
10310   ;;
10311 esac
10312 fi
10313 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10314
10315 if test -n "$OBJDUMP_FOR_TARGET"; then
10316   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10317 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10318 else
10319   echo "$as_me:$LINENO: result: no" >&5
10320 echo "${ECHO_T}no" >&6
10321 fi
10322
10323 fi
10324 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10325
10326
10327 if test -n "$OBJDUMP_FOR_TARGET"; then
10328   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10329 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10330   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10331 fi
10332
10333 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10334   for ncn_progname in objdump; do
10335     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10336 set dummy ${ncn_progname}; ac_word=$2
10337 echo "$as_me:$LINENO: checking for $ac_word" >&5
10338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10339 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10340   echo $ECHO_N "(cached) $ECHO_C" >&6
10341 else
10342   if test -n "$OBJDUMP_FOR_TARGET"; then
10343   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10344 else
10345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10346 for as_dir in $PATH
10347 do
10348   IFS=$as_save_IFS
10349   test -z "$as_dir" && as_dir=.
10350   for ac_exec_ext in '' $ac_executable_extensions; do
10351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10352     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10354     break 2
10355   fi
10356 done
10357 done
10358
10359 fi
10360 fi
10361 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10362 if test -n "$OBJDUMP_FOR_TARGET"; then
10363   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10364 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10365 else
10366   echo "$as_me:$LINENO: result: no" >&5
10367 echo "${ECHO_T}no" >&6
10368 fi
10369
10370   done
10371 fi
10372
10373 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10374   for ncn_progname in objdump; do
10375     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10376 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10377     if test -x $with_build_time_tools/${ncn_progname}; then
10378       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10379       echo "$as_me:$LINENO: result: yes" >&5
10380 echo "${ECHO_T}yes" >&6
10381       break
10382     else
10383       echo "$as_me:$LINENO: result: no" >&5
10384 echo "${ECHO_T}no" >&6
10385     fi
10386   done
10387 fi
10388
10389 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10390   for ncn_progname in objdump; do
10391     if test -n "$ncn_target_tool_prefix"; then
10392       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10393 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10394 echo "$as_me:$LINENO: checking for $ac_word" >&5
10395 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10396 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10397   echo $ECHO_N "(cached) $ECHO_C" >&6
10398 else
10399   if test -n "$OBJDUMP_FOR_TARGET"; then
10400   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10401 else
10402 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10403 for as_dir in $PATH
10404 do
10405   IFS=$as_save_IFS
10406   test -z "$as_dir" && as_dir=.
10407   for ac_exec_ext in '' $ac_executable_extensions; do
10408   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10409     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10410     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10411     break 2
10412   fi
10413 done
10414 done
10415
10416 fi
10417 fi
10418 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10419 if test -n "$OBJDUMP_FOR_TARGET"; then
10420   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10421 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10422 else
10423   echo "$as_me:$LINENO: result: no" >&5
10424 echo "${ECHO_T}no" >&6
10425 fi
10426
10427     fi
10428     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10429       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10430 set dummy ${ncn_progname}; ac_word=$2
10431 echo "$as_me:$LINENO: checking for $ac_word" >&5
10432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10433 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10434   echo $ECHO_N "(cached) $ECHO_C" >&6
10435 else
10436   if test -n "$OBJDUMP_FOR_TARGET"; then
10437   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10438 else
10439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10440 for as_dir in $PATH
10441 do
10442   IFS=$as_save_IFS
10443   test -z "$as_dir" && as_dir=.
10444   for ac_exec_ext in '' $ac_executable_extensions; do
10445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10446     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10448     break 2
10449   fi
10450 done
10451 done
10452
10453 fi
10454 fi
10455 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10456 if test -n "$OBJDUMP_FOR_TARGET"; then
10457   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10458 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10459 else
10460   echo "$as_me:$LINENO: result: no" >&5
10461 echo "${ECHO_T}no" >&6
10462 fi
10463
10464     fi
10465     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10466   done
10467 fi
10468
10469 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10470   set dummy objdump
10471   if test $build = $target ; then
10472     OBJDUMP_FOR_TARGET="$2"
10473   else
10474     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10475   fi
10476 else
10477   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10478 fi
10479
10480 else
10481   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10482 fi
10483
10484
10485
10486
10487 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10488   if test -n "$with_build_time_tools"; then
10489     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10490 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10491     if test -x $with_build_time_tools/ranlib; then
10492       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10493       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10494       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10495 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10496     else
10497       echo "$as_me:$LINENO: result: no" >&5
10498 echo "${ECHO_T}no" >&6
10499     fi
10500   elif test $build != $host && test $have_gcc_for_target = yes; then
10501     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10502     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10503     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10504   fi
10505 fi
10506 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10507   # Extract the first word of "ranlib", so it can be a program name with args.
10508 set dummy ranlib; ac_word=$2
10509 echo "$as_me:$LINENO: checking for $ac_word" >&5
10510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10511 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10512   echo $ECHO_N "(cached) $ECHO_C" >&6
10513 else
10514   case $RANLIB_FOR_TARGET in
10515   [\\/]* | ?:[\\/]*)
10516   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10517   ;;
10518   *)
10519   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10520 for as_dir in $gcc_cv_tool_dirs
10521 do
10522   IFS=$as_save_IFS
10523   test -z "$as_dir" && as_dir=.
10524   for ac_exec_ext in '' $ac_executable_extensions; do
10525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10526     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10528     break 2
10529   fi
10530 done
10531 done
10532
10533   ;;
10534 esac
10535 fi
10536 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10537
10538 if test -n "$RANLIB_FOR_TARGET"; then
10539   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10540 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10541 else
10542   echo "$as_me:$LINENO: result: no" >&5
10543 echo "${ECHO_T}no" >&6
10544 fi
10545
10546 fi
10547 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10548
10549
10550 if test -n "$RANLIB_FOR_TARGET"; then
10551   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10552 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10553   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10554 fi
10555
10556 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10557   for ncn_progname in ranlib; do
10558     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10559 set dummy ${ncn_progname}; ac_word=$2
10560 echo "$as_me:$LINENO: checking for $ac_word" >&5
10561 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10562 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10563   echo $ECHO_N "(cached) $ECHO_C" >&6
10564 else
10565   if test -n "$RANLIB_FOR_TARGET"; then
10566   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10567 else
10568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10569 for as_dir in $PATH
10570 do
10571   IFS=$as_save_IFS
10572   test -z "$as_dir" && as_dir=.
10573   for ac_exec_ext in '' $ac_executable_extensions; do
10574   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10575     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10576     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10577     break 2
10578   fi
10579 done
10580 done
10581
10582 fi
10583 fi
10584 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10585 if test -n "$RANLIB_FOR_TARGET"; then
10586   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10587 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10588 else
10589   echo "$as_me:$LINENO: result: no" >&5
10590 echo "${ECHO_T}no" >&6
10591 fi
10592
10593   done
10594 fi
10595
10596 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10597   for ncn_progname in ranlib; do
10598     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10599 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10600     if test -x $with_build_time_tools/${ncn_progname}; then
10601       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10602       echo "$as_me:$LINENO: result: yes" >&5
10603 echo "${ECHO_T}yes" >&6
10604       break
10605     else
10606       echo "$as_me:$LINENO: result: no" >&5
10607 echo "${ECHO_T}no" >&6
10608     fi
10609   done
10610 fi
10611
10612 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10613   for ncn_progname in ranlib; do
10614     if test -n "$ncn_target_tool_prefix"; then
10615       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10616 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10617 echo "$as_me:$LINENO: checking for $ac_word" >&5
10618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10619 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10620   echo $ECHO_N "(cached) $ECHO_C" >&6
10621 else
10622   if test -n "$RANLIB_FOR_TARGET"; then
10623   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10624 else
10625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10626 for as_dir in $PATH
10627 do
10628   IFS=$as_save_IFS
10629   test -z "$as_dir" && as_dir=.
10630   for ac_exec_ext in '' $ac_executable_extensions; do
10631   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10632     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10633     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10634     break 2
10635   fi
10636 done
10637 done
10638
10639 fi
10640 fi
10641 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10642 if test -n "$RANLIB_FOR_TARGET"; then
10643   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10644 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10645 else
10646   echo "$as_me:$LINENO: result: no" >&5
10647 echo "${ECHO_T}no" >&6
10648 fi
10649
10650     fi
10651     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10652       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10653 set dummy ${ncn_progname}; ac_word=$2
10654 echo "$as_me:$LINENO: checking for $ac_word" >&5
10655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10656 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10657   echo $ECHO_N "(cached) $ECHO_C" >&6
10658 else
10659   if test -n "$RANLIB_FOR_TARGET"; then
10660   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10661 else
10662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10663 for as_dir in $PATH
10664 do
10665   IFS=$as_save_IFS
10666   test -z "$as_dir" && as_dir=.
10667   for ac_exec_ext in '' $ac_executable_extensions; do
10668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10669     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10671     break 2
10672   fi
10673 done
10674 done
10675
10676 fi
10677 fi
10678 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10679 if test -n "$RANLIB_FOR_TARGET"; then
10680   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10681 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10682 else
10683   echo "$as_me:$LINENO: result: no" >&5
10684 echo "${ECHO_T}no" >&6
10685 fi
10686
10687     fi
10688     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10689   done
10690 fi
10691
10692 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10693   set dummy ranlib
10694   if test $build = $target ; then
10695     RANLIB_FOR_TARGET="$2"
10696   else
10697     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10698   fi
10699 else
10700   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10701 fi
10702
10703 else
10704   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10705 fi
10706
10707
10708
10709
10710 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10711   if test -n "$with_build_time_tools"; then
10712     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10713 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10714     if test -x $with_build_time_tools/strip; then
10715       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10716       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10717       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10718 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10719     else
10720       echo "$as_me:$LINENO: result: no" >&5
10721 echo "${ECHO_T}no" >&6
10722     fi
10723   elif test $build != $host && test $have_gcc_for_target = yes; then
10724     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10725     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10726     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10727   fi
10728 fi
10729 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10730   # Extract the first word of "strip", so it can be a program name with args.
10731 set dummy strip; ac_word=$2
10732 echo "$as_me:$LINENO: checking for $ac_word" >&5
10733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10734 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10735   echo $ECHO_N "(cached) $ECHO_C" >&6
10736 else
10737   case $STRIP_FOR_TARGET in
10738   [\\/]* | ?:[\\/]*)
10739   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10740   ;;
10741   *)
10742   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10743 for as_dir in $gcc_cv_tool_dirs
10744 do
10745   IFS=$as_save_IFS
10746   test -z "$as_dir" && as_dir=.
10747   for ac_exec_ext in '' $ac_executable_extensions; do
10748   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10749     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10750     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10751     break 2
10752   fi
10753 done
10754 done
10755
10756   ;;
10757 esac
10758 fi
10759 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10760
10761 if test -n "$STRIP_FOR_TARGET"; then
10762   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10763 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10764 else
10765   echo "$as_me:$LINENO: result: no" >&5
10766 echo "${ECHO_T}no" >&6
10767 fi
10768
10769 fi
10770 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10771
10772
10773 if test -n "$STRIP_FOR_TARGET"; then
10774   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10775 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10776   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10777 fi
10778
10779 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10780   for ncn_progname in strip; do
10781     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10782 set dummy ${ncn_progname}; ac_word=$2
10783 echo "$as_me:$LINENO: checking for $ac_word" >&5
10784 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10785 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10786   echo $ECHO_N "(cached) $ECHO_C" >&6
10787 else
10788   if test -n "$STRIP_FOR_TARGET"; then
10789   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10790 else
10791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10792 for as_dir in $PATH
10793 do
10794   IFS=$as_save_IFS
10795   test -z "$as_dir" && as_dir=.
10796   for ac_exec_ext in '' $ac_executable_extensions; do
10797   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10798     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10799     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10800     break 2
10801   fi
10802 done
10803 done
10804
10805 fi
10806 fi
10807 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10808 if test -n "$STRIP_FOR_TARGET"; then
10809   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10810 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10811 else
10812   echo "$as_me:$LINENO: result: no" >&5
10813 echo "${ECHO_T}no" >&6
10814 fi
10815
10816   done
10817 fi
10818
10819 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10820   for ncn_progname in strip; do
10821     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10822 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10823     if test -x $with_build_time_tools/${ncn_progname}; then
10824       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10825       echo "$as_me:$LINENO: result: yes" >&5
10826 echo "${ECHO_T}yes" >&6
10827       break
10828     else
10829       echo "$as_me:$LINENO: result: no" >&5
10830 echo "${ECHO_T}no" >&6
10831     fi
10832   done
10833 fi
10834
10835 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10836   for ncn_progname in strip; do
10837     if test -n "$ncn_target_tool_prefix"; then
10838       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10839 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10840 echo "$as_me:$LINENO: checking for $ac_word" >&5
10841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10842 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10843   echo $ECHO_N "(cached) $ECHO_C" >&6
10844 else
10845   if test -n "$STRIP_FOR_TARGET"; then
10846   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10847 else
10848 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10849 for as_dir in $PATH
10850 do
10851   IFS=$as_save_IFS
10852   test -z "$as_dir" && as_dir=.
10853   for ac_exec_ext in '' $ac_executable_extensions; do
10854   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10855     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10856     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10857     break 2
10858   fi
10859 done
10860 done
10861
10862 fi
10863 fi
10864 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10865 if test -n "$STRIP_FOR_TARGET"; then
10866   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10867 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10868 else
10869   echo "$as_me:$LINENO: result: no" >&5
10870 echo "${ECHO_T}no" >&6
10871 fi
10872
10873     fi
10874     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10875       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10876 set dummy ${ncn_progname}; ac_word=$2
10877 echo "$as_me:$LINENO: checking for $ac_word" >&5
10878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10879 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10880   echo $ECHO_N "(cached) $ECHO_C" >&6
10881 else
10882   if test -n "$STRIP_FOR_TARGET"; then
10883   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10884 else
10885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10886 for as_dir in $PATH
10887 do
10888   IFS=$as_save_IFS
10889   test -z "$as_dir" && as_dir=.
10890   for ac_exec_ext in '' $ac_executable_extensions; do
10891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10892     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10894     break 2
10895   fi
10896 done
10897 done
10898
10899 fi
10900 fi
10901 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10902 if test -n "$STRIP_FOR_TARGET"; then
10903   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10904 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10905 else
10906   echo "$as_me:$LINENO: result: no" >&5
10907 echo "${ECHO_T}no" >&6
10908 fi
10909
10910     fi
10911     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10912   done
10913 fi
10914
10915 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10916   set dummy strip
10917   if test $build = $target ; then
10918     STRIP_FOR_TARGET="$2"
10919   else
10920     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10921   fi
10922 else
10923   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10924 fi
10925
10926 else
10927   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10928 fi
10929
10930
10931
10932
10933 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10934   if test -n "$with_build_time_tools"; then
10935     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10936 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10937     if test -x $with_build_time_tools/windres; then
10938       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10939       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10940       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10941 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10942     else
10943       echo "$as_me:$LINENO: result: no" >&5
10944 echo "${ECHO_T}no" >&6
10945     fi
10946   elif test $build != $host && test $have_gcc_for_target = yes; then
10947     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10948     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10949     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10950   fi
10951 fi
10952 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10953   # Extract the first word of "windres", so it can be a program name with args.
10954 set dummy windres; ac_word=$2
10955 echo "$as_me:$LINENO: checking for $ac_word" >&5
10956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10957 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10958   echo $ECHO_N "(cached) $ECHO_C" >&6
10959 else
10960   case $WINDRES_FOR_TARGET in
10961   [\\/]* | ?:[\\/]*)
10962   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10963   ;;
10964   *)
10965   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10966 for as_dir in $gcc_cv_tool_dirs
10967 do
10968   IFS=$as_save_IFS
10969   test -z "$as_dir" && as_dir=.
10970   for ac_exec_ext in '' $ac_executable_extensions; do
10971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10972     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10974     break 2
10975   fi
10976 done
10977 done
10978
10979   ;;
10980 esac
10981 fi
10982 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10983
10984 if test -n "$WINDRES_FOR_TARGET"; then
10985   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10986 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10987 else
10988   echo "$as_me:$LINENO: result: no" >&5
10989 echo "${ECHO_T}no" >&6
10990 fi
10991
10992 fi
10993 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10994
10995
10996 if test -n "$WINDRES_FOR_TARGET"; then
10997   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10998 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10999   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11000 fi
11001
11002 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11003   for ncn_progname in windres; do
11004     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11005 set dummy ${ncn_progname}; ac_word=$2
11006 echo "$as_me:$LINENO: checking for $ac_word" >&5
11007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11008 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11009   echo $ECHO_N "(cached) $ECHO_C" >&6
11010 else
11011   if test -n "$WINDRES_FOR_TARGET"; then
11012   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11013 else
11014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11015 for as_dir in $PATH
11016 do
11017   IFS=$as_save_IFS
11018   test -z "$as_dir" && as_dir=.
11019   for ac_exec_ext in '' $ac_executable_extensions; do
11020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11021     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11023     break 2
11024   fi
11025 done
11026 done
11027
11028 fi
11029 fi
11030 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11031 if test -n "$WINDRES_FOR_TARGET"; then
11032   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11033 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11034 else
11035   echo "$as_me:$LINENO: result: no" >&5
11036 echo "${ECHO_T}no" >&6
11037 fi
11038
11039   done
11040 fi
11041
11042 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11043   for ncn_progname in windres; do
11044     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11045 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11046     if test -x $with_build_time_tools/${ncn_progname}; then
11047       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11048       echo "$as_me:$LINENO: result: yes" >&5
11049 echo "${ECHO_T}yes" >&6
11050       break
11051     else
11052       echo "$as_me:$LINENO: result: no" >&5
11053 echo "${ECHO_T}no" >&6
11054     fi
11055   done
11056 fi
11057
11058 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11059   for ncn_progname in windres; do
11060     if test -n "$ncn_target_tool_prefix"; then
11061       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11062 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11063 echo "$as_me:$LINENO: checking for $ac_word" >&5
11064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11065 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11066   echo $ECHO_N "(cached) $ECHO_C" >&6
11067 else
11068   if test -n "$WINDRES_FOR_TARGET"; then
11069   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11070 else
11071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11072 for as_dir in $PATH
11073 do
11074   IFS=$as_save_IFS
11075   test -z "$as_dir" && as_dir=.
11076   for ac_exec_ext in '' $ac_executable_extensions; do
11077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11078     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11080     break 2
11081   fi
11082 done
11083 done
11084
11085 fi
11086 fi
11087 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11088 if test -n "$WINDRES_FOR_TARGET"; then
11089   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11090 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11091 else
11092   echo "$as_me:$LINENO: result: no" >&5
11093 echo "${ECHO_T}no" >&6
11094 fi
11095
11096     fi
11097     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11098       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11099 set dummy ${ncn_progname}; ac_word=$2
11100 echo "$as_me:$LINENO: checking for $ac_word" >&5
11101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11102 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11103   echo $ECHO_N "(cached) $ECHO_C" >&6
11104 else
11105   if test -n "$WINDRES_FOR_TARGET"; then
11106   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11107 else
11108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11109 for as_dir in $PATH
11110 do
11111   IFS=$as_save_IFS
11112   test -z "$as_dir" && as_dir=.
11113   for ac_exec_ext in '' $ac_executable_extensions; do
11114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11115     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11117     break 2
11118   fi
11119 done
11120 done
11121
11122 fi
11123 fi
11124 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11125 if test -n "$WINDRES_FOR_TARGET"; then
11126   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11127 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11128 else
11129   echo "$as_me:$LINENO: result: no" >&5
11130 echo "${ECHO_T}no" >&6
11131 fi
11132
11133     fi
11134     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11135   done
11136 fi
11137
11138 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11139   set dummy windres
11140   if test $build = $target ; then
11141     WINDRES_FOR_TARGET="$2"
11142   else
11143     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11144   fi
11145 else
11146   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11147 fi
11148
11149 else
11150   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11151 fi
11152
11153
11154
11155
11156 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11157   if test -n "$with_build_time_tools"; then
11158     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11159 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11160     if test -x $with_build_time_tools/windmc; then
11161       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11162       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11163       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11164 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11165     else
11166       echo "$as_me:$LINENO: result: no" >&5
11167 echo "${ECHO_T}no" >&6
11168     fi
11169   elif test $build != $host && test $have_gcc_for_target = yes; then
11170     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11171     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11172     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11173   fi
11174 fi
11175 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11176   # Extract the first word of "windmc", so it can be a program name with args.
11177 set dummy windmc; ac_word=$2
11178 echo "$as_me:$LINENO: checking for $ac_word" >&5
11179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11180 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11181   echo $ECHO_N "(cached) $ECHO_C" >&6
11182 else
11183   case $WINDMC_FOR_TARGET in
11184   [\\/]* | ?:[\\/]*)
11185   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11186   ;;
11187   *)
11188   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11189 for as_dir in $gcc_cv_tool_dirs
11190 do
11191   IFS=$as_save_IFS
11192   test -z "$as_dir" && as_dir=.
11193   for ac_exec_ext in '' $ac_executable_extensions; do
11194   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11195     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11196     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11197     break 2
11198   fi
11199 done
11200 done
11201
11202   ;;
11203 esac
11204 fi
11205 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11206
11207 if test -n "$WINDMC_FOR_TARGET"; then
11208   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11209 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11210 else
11211   echo "$as_me:$LINENO: result: no" >&5
11212 echo "${ECHO_T}no" >&6
11213 fi
11214
11215 fi
11216 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11217
11218
11219 if test -n "$WINDMC_FOR_TARGET"; then
11220   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11221 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11222   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11223 fi
11224
11225 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11226   for ncn_progname in windmc; do
11227     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11228 set dummy ${ncn_progname}; ac_word=$2
11229 echo "$as_me:$LINENO: checking for $ac_word" >&5
11230 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11231 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11232   echo $ECHO_N "(cached) $ECHO_C" >&6
11233 else
11234   if test -n "$WINDMC_FOR_TARGET"; then
11235   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11236 else
11237 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11238 for as_dir in $PATH
11239 do
11240   IFS=$as_save_IFS
11241   test -z "$as_dir" && as_dir=.
11242   for ac_exec_ext in '' $ac_executable_extensions; do
11243   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11244     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11246     break 2
11247   fi
11248 done
11249 done
11250
11251 fi
11252 fi
11253 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11254 if test -n "$WINDMC_FOR_TARGET"; then
11255   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11256 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11257 else
11258   echo "$as_me:$LINENO: result: no" >&5
11259 echo "${ECHO_T}no" >&6
11260 fi
11261
11262   done
11263 fi
11264
11265 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11266   for ncn_progname in windmc; do
11267     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11268 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11269     if test -x $with_build_time_tools/${ncn_progname}; then
11270       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11271       echo "$as_me:$LINENO: result: yes" >&5
11272 echo "${ECHO_T}yes" >&6
11273       break
11274     else
11275       echo "$as_me:$LINENO: result: no" >&5
11276 echo "${ECHO_T}no" >&6
11277     fi
11278   done
11279 fi
11280
11281 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11282   for ncn_progname in windmc; do
11283     if test -n "$ncn_target_tool_prefix"; then
11284       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11285 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11286 echo "$as_me:$LINENO: checking for $ac_word" >&5
11287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11288 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11289   echo $ECHO_N "(cached) $ECHO_C" >&6
11290 else
11291   if test -n "$WINDMC_FOR_TARGET"; then
11292   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11293 else
11294 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11295 for as_dir in $PATH
11296 do
11297   IFS=$as_save_IFS
11298   test -z "$as_dir" && as_dir=.
11299   for ac_exec_ext in '' $ac_executable_extensions; do
11300   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11301     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11302     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11303     break 2
11304   fi
11305 done
11306 done
11307
11308 fi
11309 fi
11310 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11311 if test -n "$WINDMC_FOR_TARGET"; then
11312   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11313 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11314 else
11315   echo "$as_me:$LINENO: result: no" >&5
11316 echo "${ECHO_T}no" >&6
11317 fi
11318
11319     fi
11320     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11321       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11322 set dummy ${ncn_progname}; ac_word=$2
11323 echo "$as_me:$LINENO: checking for $ac_word" >&5
11324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11325 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11326   echo $ECHO_N "(cached) $ECHO_C" >&6
11327 else
11328   if test -n "$WINDMC_FOR_TARGET"; then
11329   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11330 else
11331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11332 for as_dir in $PATH
11333 do
11334   IFS=$as_save_IFS
11335   test -z "$as_dir" && as_dir=.
11336   for ac_exec_ext in '' $ac_executable_extensions; do
11337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11338     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11340     break 2
11341   fi
11342 done
11343 done
11344
11345 fi
11346 fi
11347 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11348 if test -n "$WINDMC_FOR_TARGET"; then
11349   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11350 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11351 else
11352   echo "$as_me:$LINENO: result: no" >&5
11353 echo "${ECHO_T}no" >&6
11354 fi
11355
11356     fi
11357     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11358   done
11359 fi
11360
11361 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11362   set dummy windmc
11363   if test $build = $target ; then
11364     WINDMC_FOR_TARGET="$2"
11365   else
11366     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11367   fi
11368 else
11369   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11370 fi
11371
11372 else
11373   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11374 fi
11375
11376
11377 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11378
11379 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11380 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11381 if test "x${build}" != "x${host}" ; then
11382   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11383     # We already found the complete path
11384     ac_dir=`dirname $AR_FOR_TARGET`
11385     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11386 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11387   else
11388     # Canadian cross, just use what we found
11389     echo "$as_me:$LINENO: result: pre-installed" >&5
11390 echo "${ECHO_T}pre-installed" >&6
11391   fi
11392 else
11393   ok=yes
11394   case " ${configdirs} " in
11395     *" binutils "*) ;;
11396     *) ok=no ;;
11397   esac
11398
11399   if test $ok = yes; then
11400     # An in-tree tool is available and we can use it
11401     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11402     echo "$as_me:$LINENO: result: just compiled" >&5
11403 echo "${ECHO_T}just compiled" >&6
11404   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11405     # We already found the complete path
11406     ac_dir=`dirname $AR_FOR_TARGET`
11407     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11408 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11409   elif test "x$target" = "x$host"; then
11410     # We can use an host tool
11411     AR_FOR_TARGET='$(AR)'
11412     echo "$as_me:$LINENO: result: host tool" >&5
11413 echo "${ECHO_T}host tool" >&6
11414   else
11415     # We need a cross tool
11416     echo "$as_me:$LINENO: result: pre-installed" >&5
11417 echo "${ECHO_T}pre-installed" >&6
11418   fi
11419 fi
11420
11421 echo "$as_me:$LINENO: checking where to find the target as" >&5
11422 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11423 if test "x${build}" != "x${host}" ; then
11424   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11425     # We already found the complete path
11426     ac_dir=`dirname $AS_FOR_TARGET`
11427     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11428 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11429   else
11430     # Canadian cross, just use what we found
11431     echo "$as_me:$LINENO: result: pre-installed" >&5
11432 echo "${ECHO_T}pre-installed" >&6
11433   fi
11434 else
11435   ok=yes
11436   case " ${configdirs} " in
11437     *" gas "*) ;;
11438     *) ok=no ;;
11439   esac
11440
11441   if test $ok = yes; then
11442     # An in-tree tool is available and we can use it
11443     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11444     echo "$as_me:$LINENO: result: just compiled" >&5
11445 echo "${ECHO_T}just compiled" >&6
11446   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11447     # We already found the complete path
11448     ac_dir=`dirname $AS_FOR_TARGET`
11449     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11450 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11451   elif test "x$target" = "x$host"; then
11452     # We can use an host tool
11453     AS_FOR_TARGET='$(AS)'
11454     echo "$as_me:$LINENO: result: host tool" >&5
11455 echo "${ECHO_T}host tool" >&6
11456   else
11457     # We need a cross tool
11458     echo "$as_me:$LINENO: result: pre-installed" >&5
11459 echo "${ECHO_T}pre-installed" >&6
11460   fi
11461 fi
11462
11463 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11464 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11465 if test "x${build}" != "x${host}" ; then
11466   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11467     # We already found the complete path
11468     ac_dir=`dirname $CC_FOR_TARGET`
11469     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11470 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11471   else
11472     # Canadian cross, just use what we found
11473     echo "$as_me:$LINENO: result: pre-installed" >&5
11474 echo "${ECHO_T}pre-installed" >&6
11475   fi
11476 else
11477   ok=yes
11478   case " ${configdirs} " in
11479     *" gcc "*) ;;
11480     *) ok=no ;;
11481   esac
11482
11483   if test $ok = yes; then
11484     # An in-tree tool is available and we can use it
11485     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11486     echo "$as_me:$LINENO: result: just compiled" >&5
11487 echo "${ECHO_T}just compiled" >&6
11488   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11489     # We already found the complete path
11490     ac_dir=`dirname $CC_FOR_TARGET`
11491     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11492 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11493   elif test "x$target" = "x$host"; then
11494     # We can use an host tool
11495     CC_FOR_TARGET='$(CC)'
11496     echo "$as_me:$LINENO: result: host tool" >&5
11497 echo "${ECHO_T}host tool" >&6
11498   else
11499     # We need a cross tool
11500     echo "$as_me:$LINENO: result: pre-installed" >&5
11501 echo "${ECHO_T}pre-installed" >&6
11502   fi
11503 fi
11504
11505 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11506 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11507 if test "x${build}" != "x${host}" ; then
11508   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11509     # We already found the complete path
11510     ac_dir=`dirname $CXX_FOR_TARGET`
11511     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11512 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11513   else
11514     # Canadian cross, just use what we found
11515     echo "$as_me:$LINENO: result: pre-installed" >&5
11516 echo "${ECHO_T}pre-installed" >&6
11517   fi
11518 else
11519   ok=yes
11520   case " ${configdirs} " in
11521     *" gcc "*) ;;
11522     *) ok=no ;;
11523   esac
11524   case ,${enable_languages}, in
11525     *,c++,*) ;;
11526     *) ok=no ;;
11527   esac
11528   if test $ok = yes; then
11529     # An in-tree tool is available and we can use it
11530     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'
11531     echo "$as_me:$LINENO: result: just compiled" >&5
11532 echo "${ECHO_T}just compiled" >&6
11533   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11534     # We already found the complete path
11535     ac_dir=`dirname $CXX_FOR_TARGET`
11536     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11537 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11538   elif test "x$target" = "x$host"; then
11539     # We can use an host tool
11540     CXX_FOR_TARGET='$(CXX)'
11541     echo "$as_me:$LINENO: result: host tool" >&5
11542 echo "${ECHO_T}host tool" >&6
11543   else
11544     # We need a cross tool
11545     echo "$as_me:$LINENO: result: pre-installed" >&5
11546 echo "${ECHO_T}pre-installed" >&6
11547   fi
11548 fi
11549
11550 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11551 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11552 if test "x${build}" != "x${host}" ; then
11553   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11554     # We already found the complete path
11555     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11556     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11557 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11558   else
11559     # Canadian cross, just use what we found
11560     echo "$as_me:$LINENO: result: pre-installed" >&5
11561 echo "${ECHO_T}pre-installed" >&6
11562   fi
11563 else
11564   ok=yes
11565   case " ${configdirs} " in
11566     *" gcc "*) ;;
11567     *) ok=no ;;
11568   esac
11569   case ,${enable_languages}, in
11570     *,c++,*) ;;
11571     *) ok=no ;;
11572   esac
11573   if test $ok = yes; then
11574     # An in-tree tool is available and we can use it
11575     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'
11576     echo "$as_me:$LINENO: result: just compiled" >&5
11577 echo "${ECHO_T}just compiled" >&6
11578   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11579     # We already found the complete path
11580     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11581     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11582 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11583   elif test "x$target" = "x$host"; then
11584     # We can use an host tool
11585     RAW_CXX_FOR_TARGET='$(CXX)'
11586     echo "$as_me:$LINENO: result: host tool" >&5
11587 echo "${ECHO_T}host tool" >&6
11588   else
11589     # We need a cross tool
11590     echo "$as_me:$LINENO: result: pre-installed" >&5
11591 echo "${ECHO_T}pre-installed" >&6
11592   fi
11593 fi
11594
11595 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11596 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11597 if test "x${build}" != "x${host}" ; then
11598   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11599     # We already found the complete path
11600     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11601     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11602 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11603   else
11604     # Canadian cross, just use what we found
11605     echo "$as_me:$LINENO: result: pre-installed" >&5
11606 echo "${ECHO_T}pre-installed" >&6
11607   fi
11608 else
11609   ok=yes
11610   case " ${configdirs} " in
11611     *" binutils "*) ;;
11612     *) ok=no ;;
11613   esac
11614
11615   if test $ok = yes; then
11616     # An in-tree tool is available and we can use it
11617     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11618     echo "$as_me:$LINENO: result: just compiled" >&5
11619 echo "${ECHO_T}just compiled" >&6
11620   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11621     # We already found the complete path
11622     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11623     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11624 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11625   elif test "x$target" = "x$host"; then
11626     # We can use an host tool
11627     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11628     echo "$as_me:$LINENO: result: host tool" >&5
11629 echo "${ECHO_T}host tool" >&6
11630   else
11631     # We need a cross tool
11632     echo "$as_me:$LINENO: result: pre-installed" >&5
11633 echo "${ECHO_T}pre-installed" >&6
11634   fi
11635 fi
11636
11637 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11638 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11639 if test "x${build}" != "x${host}" ; then
11640   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11641     # We already found the complete path
11642     ac_dir=`dirname $GCC_FOR_TARGET`
11643     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11644 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11645   else
11646     # Canadian cross, just use what we found
11647     echo "$as_me:$LINENO: result: pre-installed" >&5
11648 echo "${ECHO_T}pre-installed" >&6
11649   fi
11650 else
11651   ok=yes
11652   case " ${configdirs} " in
11653     *" gcc "*) ;;
11654     *) ok=no ;;
11655   esac
11656
11657   if test $ok = yes; then
11658     # An in-tree tool is available and we can use it
11659     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11660     echo "$as_me:$LINENO: result: just compiled" >&5
11661 echo "${ECHO_T}just compiled" >&6
11662   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11663     # We already found the complete path
11664     ac_dir=`dirname $GCC_FOR_TARGET`
11665     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11666 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11667   elif test "x$target" = "x$host"; then
11668     # We can use an host tool
11669     GCC_FOR_TARGET='$()'
11670     echo "$as_me:$LINENO: result: host tool" >&5
11671 echo "${ECHO_T}host tool" >&6
11672   else
11673     # We need a cross tool
11674     echo "$as_me:$LINENO: result: pre-installed" >&5
11675 echo "${ECHO_T}pre-installed" >&6
11676   fi
11677 fi
11678
11679 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11680 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11681 if test "x${build}" != "x${host}" ; then
11682   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11683     # We already found the complete path
11684     ac_dir=`dirname $GCJ_FOR_TARGET`
11685     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11686 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11687   else
11688     # Canadian cross, just use what we found
11689     echo "$as_me:$LINENO: result: pre-installed" >&5
11690 echo "${ECHO_T}pre-installed" >&6
11691   fi
11692 else
11693   ok=yes
11694   case " ${configdirs} " in
11695     *" gcc "*) ;;
11696     *) ok=no ;;
11697   esac
11698   case ,${enable_languages}, in
11699     *,java,*) ;;
11700     *) ok=no ;;
11701   esac
11702   if test $ok = yes; then
11703     # An in-tree tool is available and we can use it
11704     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11705     echo "$as_me:$LINENO: result: just compiled" >&5
11706 echo "${ECHO_T}just compiled" >&6
11707   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11708     # We already found the complete path
11709     ac_dir=`dirname $GCJ_FOR_TARGET`
11710     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11711 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11712   elif test "x$target" = "x$host"; then
11713     # We can use an host tool
11714     GCJ_FOR_TARGET='$(GCJ)'
11715     echo "$as_me:$LINENO: result: host tool" >&5
11716 echo "${ECHO_T}host tool" >&6
11717   else
11718     # We need a cross tool
11719     echo "$as_me:$LINENO: result: pre-installed" >&5
11720 echo "${ECHO_T}pre-installed" >&6
11721   fi
11722 fi
11723
11724 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11725 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11726 if test "x${build}" != "x${host}" ; then
11727   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11728     # We already found the complete path
11729     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11730     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11731 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11732   else
11733     # Canadian cross, just use what we found
11734     echo "$as_me:$LINENO: result: pre-installed" >&5
11735 echo "${ECHO_T}pre-installed" >&6
11736   fi
11737 else
11738   ok=yes
11739   case " ${configdirs} " in
11740     *" gcc "*) ;;
11741     *) ok=no ;;
11742   esac
11743   case ,${enable_languages}, in
11744     *,fortran,*) ;;
11745     *) ok=no ;;
11746   esac
11747   if test $ok = yes; then
11748     # An in-tree tool is available and we can use it
11749     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11750     echo "$as_me:$LINENO: result: just compiled" >&5
11751 echo "${ECHO_T}just compiled" >&6
11752   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11753     # We already found the complete path
11754     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11755     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11756 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11757   elif test "x$target" = "x$host"; then
11758     # We can use an host tool
11759     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11760     echo "$as_me:$LINENO: result: host tool" >&5
11761 echo "${ECHO_T}host tool" >&6
11762   else
11763     # We need a cross tool
11764     echo "$as_me:$LINENO: result: pre-installed" >&5
11765 echo "${ECHO_T}pre-installed" >&6
11766   fi
11767 fi
11768
11769 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11770 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11771 if test "x${build}" != "x${host}" ; then
11772   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11773     # We already found the complete path
11774     ac_dir=`dirname $LD_FOR_TARGET`
11775     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11776 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11777   else
11778     # Canadian cross, just use what we found
11779     echo "$as_me:$LINENO: result: pre-installed" >&5
11780 echo "${ECHO_T}pre-installed" >&6
11781   fi
11782 else
11783   ok=yes
11784   case " ${configdirs} " in
11785     *" ld "*) ;;
11786     *) ok=no ;;
11787   esac
11788
11789   if test $ok = yes; then
11790     # An in-tree tool is available and we can use it
11791     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11792     echo "$as_me:$LINENO: result: just compiled" >&5
11793 echo "${ECHO_T}just compiled" >&6
11794   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11795     # We already found the complete path
11796     ac_dir=`dirname $LD_FOR_TARGET`
11797     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11798 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11799   elif test "x$target" = "x$host"; then
11800     # We can use an host tool
11801     LD_FOR_TARGET='$(LD)'
11802     echo "$as_me:$LINENO: result: host tool" >&5
11803 echo "${ECHO_T}host tool" >&6
11804   else
11805     # We need a cross tool
11806     echo "$as_me:$LINENO: result: pre-installed" >&5
11807 echo "${ECHO_T}pre-installed" >&6
11808   fi
11809 fi
11810
11811 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11812 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11813 if test "x${build}" != "x${host}" ; then
11814   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11815     # We already found the complete path
11816     ac_dir=`dirname $LIPO_FOR_TARGET`
11817     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11818 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11819   else
11820     # Canadian cross, just use what we found
11821     echo "$as_me:$LINENO: result: pre-installed" >&5
11822 echo "${ECHO_T}pre-installed" >&6
11823   fi
11824 else
11825   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11826     # We already found the complete path
11827     ac_dir=`dirname $LIPO_FOR_TARGET`
11828     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11829 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11830   elif test "x$target" = "x$host"; then
11831     # We can use an host tool
11832     LIPO_FOR_TARGET='$(LIPO)'
11833     echo "$as_me:$LINENO: result: host tool" >&5
11834 echo "${ECHO_T}host tool" >&6
11835   else
11836     # We need a cross tool
11837     echo "$as_me:$LINENO: result: pre-installed" >&5
11838 echo "${ECHO_T}pre-installed" >&6
11839   fi
11840 fi
11841
11842 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11843 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11844 if test "x${build}" != "x${host}" ; then
11845   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11846     # We already found the complete path
11847     ac_dir=`dirname $NM_FOR_TARGET`
11848     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11849 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11850   else
11851     # Canadian cross, just use what we found
11852     echo "$as_me:$LINENO: result: pre-installed" >&5
11853 echo "${ECHO_T}pre-installed" >&6
11854   fi
11855 else
11856   ok=yes
11857   case " ${configdirs} " in
11858     *" binutils "*) ;;
11859     *) ok=no ;;
11860   esac
11861
11862   if test $ok = yes; then
11863     # An in-tree tool is available and we can use it
11864     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11865     echo "$as_me:$LINENO: result: just compiled" >&5
11866 echo "${ECHO_T}just compiled" >&6
11867   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11868     # We already found the complete path
11869     ac_dir=`dirname $NM_FOR_TARGET`
11870     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11871 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11872   elif test "x$target" = "x$host"; then
11873     # We can use an host tool
11874     NM_FOR_TARGET='$(NM)'
11875     echo "$as_me:$LINENO: result: host tool" >&5
11876 echo "${ECHO_T}host tool" >&6
11877   else
11878     # We need a cross tool
11879     echo "$as_me:$LINENO: result: pre-installed" >&5
11880 echo "${ECHO_T}pre-installed" >&6
11881   fi
11882 fi
11883
11884 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11885 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11886 if test "x${build}" != "x${host}" ; then
11887   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11888     # We already found the complete path
11889     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11890     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11891 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11892   else
11893     # Canadian cross, just use what we found
11894     echo "$as_me:$LINENO: result: pre-installed" >&5
11895 echo "${ECHO_T}pre-installed" >&6
11896   fi
11897 else
11898   ok=yes
11899   case " ${configdirs} " in
11900     *" binutils "*) ;;
11901     *) ok=no ;;
11902   esac
11903
11904   if test $ok = yes; then
11905     # An in-tree tool is available and we can use it
11906     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11907     echo "$as_me:$LINENO: result: just compiled" >&5
11908 echo "${ECHO_T}just compiled" >&6
11909   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11910     # We already found the complete path
11911     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11912     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11913 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11914   elif test "x$target" = "x$host"; then
11915     # We can use an host tool
11916     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11917     echo "$as_me:$LINENO: result: host tool" >&5
11918 echo "${ECHO_T}host tool" >&6
11919   else
11920     # We need a cross tool
11921     echo "$as_me:$LINENO: result: pre-installed" >&5
11922 echo "${ECHO_T}pre-installed" >&6
11923   fi
11924 fi
11925
11926 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11927 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11928 if test "x${build}" != "x${host}" ; then
11929   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11930     # We already found the complete path
11931     ac_dir=`dirname $RANLIB_FOR_TARGET`
11932     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11933 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11934   else
11935     # Canadian cross, just use what we found
11936     echo "$as_me:$LINENO: result: pre-installed" >&5
11937 echo "${ECHO_T}pre-installed" >&6
11938   fi
11939 else
11940   ok=yes
11941   case " ${configdirs} " in
11942     *" binutils "*) ;;
11943     *) ok=no ;;
11944   esac
11945
11946   if test $ok = yes; then
11947     # An in-tree tool is available and we can use it
11948     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11949     echo "$as_me:$LINENO: result: just compiled" >&5
11950 echo "${ECHO_T}just compiled" >&6
11951   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11952     # We already found the complete path
11953     ac_dir=`dirname $RANLIB_FOR_TARGET`
11954     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11955 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11956   elif test "x$target" = "x$host"; then
11957     # We can use an host tool
11958     RANLIB_FOR_TARGET='$(RANLIB)'
11959     echo "$as_me:$LINENO: result: host tool" >&5
11960 echo "${ECHO_T}host tool" >&6
11961   else
11962     # We need a cross tool
11963     echo "$as_me:$LINENO: result: pre-installed" >&5
11964 echo "${ECHO_T}pre-installed" >&6
11965   fi
11966 fi
11967
11968 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11969 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11970 if test "x${build}" != "x${host}" ; then
11971   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11972     # We already found the complete path
11973     ac_dir=`dirname $STRIP_FOR_TARGET`
11974     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11975 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11976   else
11977     # Canadian cross, just use what we found
11978     echo "$as_me:$LINENO: result: pre-installed" >&5
11979 echo "${ECHO_T}pre-installed" >&6
11980   fi
11981 else
11982   ok=yes
11983   case " ${configdirs} " in
11984     *" binutils "*) ;;
11985     *) ok=no ;;
11986   esac
11987
11988   if test $ok = yes; then
11989     # An in-tree tool is available and we can use it
11990     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11991     echo "$as_me:$LINENO: result: just compiled" >&5
11992 echo "${ECHO_T}just compiled" >&6
11993   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11994     # We already found the complete path
11995     ac_dir=`dirname $STRIP_FOR_TARGET`
11996     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11997 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11998   elif test "x$target" = "x$host"; then
11999     # We can use an host tool
12000     STRIP_FOR_TARGET='$(STRIP)'
12001     echo "$as_me:$LINENO: result: host tool" >&5
12002 echo "${ECHO_T}host tool" >&6
12003   else
12004     # We need a cross tool
12005     echo "$as_me:$LINENO: result: pre-installed" >&5
12006 echo "${ECHO_T}pre-installed" >&6
12007   fi
12008 fi
12009
12010 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12011 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12012 if test "x${build}" != "x${host}" ; then
12013   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12014     # We already found the complete path
12015     ac_dir=`dirname $WINDRES_FOR_TARGET`
12016     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12017 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12018   else
12019     # Canadian cross, just use what we found
12020     echo "$as_me:$LINENO: result: pre-installed" >&5
12021 echo "${ECHO_T}pre-installed" >&6
12022   fi
12023 else
12024   ok=yes
12025   case " ${configdirs} " in
12026     *" binutils "*) ;;
12027     *) ok=no ;;
12028   esac
12029
12030   if test $ok = yes; then
12031     # An in-tree tool is available and we can use it
12032     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12033     echo "$as_me:$LINENO: result: just compiled" >&5
12034 echo "${ECHO_T}just compiled" >&6
12035   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12036     # We already found the complete path
12037     ac_dir=`dirname $WINDRES_FOR_TARGET`
12038     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12039 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12040   elif test "x$target" = "x$host"; then
12041     # We can use an host tool
12042     WINDRES_FOR_TARGET='$(WINDRES)'
12043     echo "$as_me:$LINENO: result: host tool" >&5
12044 echo "${ECHO_T}host tool" >&6
12045   else
12046     # We need a cross tool
12047     echo "$as_me:$LINENO: result: pre-installed" >&5
12048 echo "${ECHO_T}pre-installed" >&6
12049   fi
12050 fi
12051
12052 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12053 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12054 if test "x${build}" != "x${host}" ; then
12055   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12056     # We already found the complete path
12057     ac_dir=`dirname $WINDMC_FOR_TARGET`
12058     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12059 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12060   else
12061     # Canadian cross, just use what we found
12062     echo "$as_me:$LINENO: result: pre-installed" >&5
12063 echo "${ECHO_T}pre-installed" >&6
12064   fi
12065 else
12066   ok=yes
12067   case " ${configdirs} " in
12068     *" binutils "*) ;;
12069     *) ok=no ;;
12070   esac
12071
12072   if test $ok = yes; then
12073     # An in-tree tool is available and we can use it
12074     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12075     echo "$as_me:$LINENO: result: just compiled" >&5
12076 echo "${ECHO_T}just compiled" >&6
12077   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12078     # We already found the complete path
12079     ac_dir=`dirname $WINDMC_FOR_TARGET`
12080     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12081 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12082   elif test "x$target" = "x$host"; then
12083     # We can use an host tool
12084     WINDMC_FOR_TARGET='$(WINDMC)'
12085     echo "$as_me:$LINENO: result: host tool" >&5
12086 echo "${ECHO_T}host tool" >&6
12087   else
12088     # We need a cross tool
12089     echo "$as_me:$LINENO: result: pre-installed" >&5
12090 echo "${ECHO_T}pre-installed" >&6
12091   fi
12092 fi
12093
12094
12095
12096
12097
12098 # Certain tools may need extra flags.
12099 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12100 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12101 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12102
12103 # When building target libraries, except in a Canadian cross, we use
12104 # the same toolchain as the compiler we just built.
12105 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12106 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12107 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12108 if test $host = $build; then
12109   case " $configdirs " in
12110     *" gcc "*)
12111       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12112       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12113       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12114       ;;
12115   esac
12116 fi
12117
12118
12119
12120
12121
12122 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12123 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12124 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12125 if test "${enable_maintainer_mode+set}" = set; then
12126   enableval="$enable_maintainer_mode"
12127   USE_MAINTAINER_MODE=$enableval
12128 else
12129   USE_MAINTAINER_MODE=no
12130 fi;
12131 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12132 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12133
12134
12135 if test "$USE_MAINTAINER_MODE" = yes; then
12136   MAINTAINER_MODE_TRUE=
12137   MAINTAINER_MODE_FALSE='#'
12138 else
12139   MAINTAINER_MODE_TRUE='#'
12140   MAINTAINER_MODE_FALSE=
12141 fi
12142 MAINT=$MAINTAINER_MODE_TRUE
12143
12144 # ---------------------
12145 # GCC bootstrap support
12146 # ---------------------
12147
12148 # Stage specific cflags for build.
12149 stage1_cflags="-g"
12150 case $build in
12151   vax-*-*)
12152     case ${GCC} in
12153       yes) stage1_cflags="-g -Wa,-J" ;;
12154       *) stage1_cflags="-g -J" ;;
12155     esac ;;
12156 esac
12157
12158 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12159 if test "$GCC" = yes; then
12160   saved_CFLAGS="$CFLAGS"
12161
12162   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12163   CFLAGS="$CFLAGS -fkeep-inline-functions"
12164   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12165 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12166   cat >conftest.$ac_ext <<_ACEOF
12167 /* confdefs.h.  */
12168 _ACEOF
12169 cat confdefs.h >>conftest.$ac_ext
12170 cat >>conftest.$ac_ext <<_ACEOF
12171 /* end confdefs.h.  */
12172
12173 #if (__GNUC__ < 3) \
12174     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12175                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12176 #error http://gcc.gnu.org/PR29382
12177 #endif
12178
12179 int
12180 main ()
12181 {
12182
12183   ;
12184   return 0;
12185 }
12186 _ACEOF
12187 rm -f conftest.$ac_objext
12188 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12189   (eval $ac_compile) 2>conftest.er1
12190   ac_status=$?
12191   grep -v '^ *+' conftest.er1 >conftest.err
12192   rm -f conftest.er1
12193   cat conftest.err >&5
12194   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12195   (exit $ac_status); } &&
12196          { ac_try='test -z "$ac_c_werror_flag"
12197                          || test ! -s conftest.err'
12198   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12199   (eval $ac_try) 2>&5
12200   ac_status=$?
12201   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12202   (exit $ac_status); }; } &&
12203          { ac_try='test -s conftest.$ac_objext'
12204   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12205   (eval $ac_try) 2>&5
12206   ac_status=$?
12207   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12208   (exit $ac_status); }; }; then
12209   echo "$as_me:$LINENO: result: yes" >&5
12210 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12211 else
12212   echo "$as_me: failed program was:" >&5
12213 sed 's/^/| /' conftest.$ac_ext >&5
12214
12215 echo "$as_me:$LINENO: result: no" >&5
12216 echo "${ECHO_T}no" >&6
12217 fi
12218 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12219
12220   CFLAGS="$saved_CFLAGS"
12221 fi
12222
12223
12224
12225 # Enable --enable-checking in stage1 of the compiler.
12226 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12227 if test "${enable_stage1_checking+set}" = set; then
12228   enableval="$enable_stage1_checking"
12229   stage1_checking=--enable-checking=${enable_stage1_checking}
12230 else
12231   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12232   stage1_checking=--enable-checking=yes,types
12233 else
12234   stage1_checking=--enable-checking=$enable_checking,types
12235 fi
12236 fi;
12237
12238
12239 # Enable -Werror in bootstrap stage2 and later.
12240 # Check whether --enable-werror or --disable-werror was given.
12241 if test "${enable_werror+set}" = set; then
12242   enableval="$enable_werror"
12243
12244 else
12245   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12246   enable_werror=yes
12247 else
12248   enable_werror=no
12249 fi
12250 fi;
12251 case ${enable_werror} in
12252   yes) stage2_werror_flag="--enable-werror-always" ;;
12253   *) stage2_werror_flag="" ;;
12254 esac
12255
12256
12257 # Flags needed to enable html installing and building
12258
12259 # Check whether --with-datarootdir or --without-datarootdir was given.
12260 if test "${with_datarootdir+set}" = set; then
12261   withval="$with_datarootdir"
12262   datarootdir="\${prefix}/${withval}"
12263 else
12264   datarootdir="\${prefix}/share"
12265 fi;
12266
12267
12268 # Check whether --with-docdir or --without-docdir was given.
12269 if test "${with_docdir+set}" = set; then
12270   withval="$with_docdir"
12271   docdir="\${prefix}/${withval}"
12272 else
12273   docdir="\${datarootdir}/doc"
12274 fi;
12275
12276
12277 # Check whether --with-pdfdir or --without-pdfdir was given.
12278 if test "${with_pdfdir+set}" = set; then
12279   withval="$with_pdfdir"
12280   pdfdir="\${prefix}/${withval}"
12281 else
12282   pdfdir="\${docdir}"
12283 fi;
12284
12285
12286 # Check whether --with-htmldir or --without-htmldir was given.
12287 if test "${with_htmldir+set}" = set; then
12288   withval="$with_htmldir"
12289   htmldir="\${prefix}/${withval}"
12290 else
12291   htmldir="\${docdir}"
12292 fi;
12293
12294
12295
12296
12297
12298
12299           ac_config_files="$ac_config_files Makefile"
12300 cat >confcache <<\_ACEOF
12301 # This file is a shell script that caches the results of configure
12302 # tests run on this system so they can be shared between configure
12303 # scripts and configure runs, see configure's option --config-cache.
12304 # It is not useful on other systems.  If it contains results you don't
12305 # want to keep, you may remove or edit it.
12306 #
12307 # config.status only pays attention to the cache file if you give it
12308 # the --recheck option to rerun configure.
12309 #
12310 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12311 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12312 # following values.
12313
12314 _ACEOF
12315
12316 # The following way of writing the cache mishandles newlines in values,
12317 # but we know of no workaround that is simple, portable, and efficient.
12318 # So, don't put newlines in cache variables' values.
12319 # Ultrix sh set writes to stderr and can't be redirected directly,
12320 # and sets the high bit in the cache file unless we assign to the vars.
12321 {
12322   (set) 2>&1 |
12323     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12324     *ac_space=\ *)
12325       # `set' does not quote correctly, so add quotes (double-quote
12326       # substitution turns \\\\ into \\, and sed turns \\ into \).
12327       sed -n \
12328         "s/'/'\\\\''/g;
12329           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12330       ;;
12331     *)
12332       # `set' quotes correctly as required by POSIX, so do not add quotes.
12333       sed -n \
12334         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12335       ;;
12336     esac;
12337 } |
12338   sed '
12339      t clear
12340      : clear
12341      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12342      t end
12343      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12344      : end' >>confcache
12345 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12346   if test -w $cache_file; then
12347     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12348     cat confcache >$cache_file
12349   else
12350     echo "not updating unwritable cache $cache_file"
12351   fi
12352 fi
12353 rm -f confcache
12354
12355 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12356 # Let make expand exec_prefix.
12357 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12358
12359 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12360 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12361 # trailing colons and then remove the whole line if VPATH becomes empty
12362 # (actually we leave an empty line to preserve line numbers).
12363 if test "x$srcdir" = x.; then
12364   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12365 s/:*\$(srcdir):*/:/;
12366 s/:*\${srcdir}:*/:/;
12367 s/:*@srcdir@:*/:/;
12368 s/^\([^=]*=[     ]*\):*/\1/;
12369 s/:*$//;
12370 s/^[^=]*=[       ]*$//;
12371 }'
12372 fi
12373
12374 # Transform confdefs.h into DEFS.
12375 # Protect against shell expansion while executing Makefile rules.
12376 # Protect against Makefile macro expansion.
12377 #
12378 # If the first sed substitution is executed (which looks for macros that
12379 # take arguments), then we branch to the quote section.  Otherwise,
12380 # look for a macro that doesn't take arguments.
12381 cat >confdef2opt.sed <<\_ACEOF
12382 t clear
12383 : clear
12384 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12385 t quote
12386 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12387 t quote
12388 d
12389 : quote
12390 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12391 s,\[,\\&,g
12392 s,\],\\&,g
12393 s,\$,$$,g
12394 p
12395 _ACEOF
12396 # We use echo to avoid assuming a particular line-breaking character.
12397 # The extra dot is to prevent the shell from consuming trailing
12398 # line-breaks from the sub-command output.  A line-break within
12399 # single-quotes doesn't work because, if this script is created in a
12400 # platform that uses two characters for line-breaks (e.g., DOS), tr
12401 # would break.
12402 ac_LF_and_DOT=`echo; echo .`
12403 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12404 rm -f confdef2opt.sed
12405
12406
12407 ac_libobjs=
12408 ac_ltlibobjs=
12409 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12410   # 1. Remove the extension, and $U if already installed.
12411   ac_i=`echo "$ac_i" |
12412          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12413   # 2. Add them.
12414   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12415   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12416 done
12417 LIBOBJS=$ac_libobjs
12418
12419 LTLIBOBJS=$ac_ltlibobjs
12420
12421
12422
12423 : ${CONFIG_STATUS=./config.status}
12424 ac_clean_files_save=$ac_clean_files
12425 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12426 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12427 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12428 cat >$CONFIG_STATUS <<_ACEOF
12429 #! $SHELL
12430 # Generated by $as_me.
12431 # Run this file to recreate the current configuration.
12432 # Compiler output produced by configure, useful for debugging
12433 # configure, is in config.log if it exists.
12434
12435 debug=false
12436 ac_cs_recheck=false
12437 ac_cs_silent=false
12438 SHELL=\${CONFIG_SHELL-$SHELL}
12439 _ACEOF
12440
12441 cat >>$CONFIG_STATUS <<\_ACEOF
12442 ## --------------------- ##
12443 ## M4sh Initialization.  ##
12444 ## --------------------- ##
12445
12446 # Be Bourne compatible
12447 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12448   emulate sh
12449   NULLCMD=:
12450   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12451   # is contrary to our usage.  Disable this feature.
12452   alias -g '${1+"$@"}'='"$@"'
12453 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12454   set -o posix
12455 fi
12456 DUALCASE=1; export DUALCASE # for MKS sh
12457
12458 # Support unset when possible.
12459 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12460   as_unset=unset
12461 else
12462   as_unset=false
12463 fi
12464
12465
12466 # Work around bugs in pre-3.0 UWIN ksh.
12467 $as_unset ENV MAIL MAILPATH
12468 PS1='$ '
12469 PS2='> '
12470 PS4='+ '
12471
12472 # NLS nuisances.
12473 for as_var in \
12474   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12475   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12476   LC_TELEPHONE LC_TIME
12477 do
12478   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12479     eval $as_var=C; export $as_var
12480   else
12481     $as_unset $as_var
12482   fi
12483 done
12484
12485 # Required to use basename.
12486 if expr a : '\(a\)' >/dev/null 2>&1; then
12487   as_expr=expr
12488 else
12489   as_expr=false
12490 fi
12491
12492 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12493   as_basename=basename
12494 else
12495   as_basename=false
12496 fi
12497
12498
12499 # Name of the executable.
12500 as_me=`$as_basename "$0" ||
12501 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12502          X"$0" : 'X\(//\)$' \| \
12503          X"$0" : 'X\(/\)$' \| \
12504          .     : '\(.\)' 2>/dev/null ||
12505 echo X/"$0" |
12506     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12507           /^X\/\(\/\/\)$/{ s//\1/; q; }
12508           /^X\/\(\/\).*/{ s//\1/; q; }
12509           s/.*/./; q'`
12510
12511
12512 # PATH needs CR, and LINENO needs CR and PATH.
12513 # Avoid depending upon Character Ranges.
12514 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12515 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12516 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12517 as_cr_digits='0123456789'
12518 as_cr_alnum=$as_cr_Letters$as_cr_digits
12519
12520 # The user is always right.
12521 if test "${PATH_SEPARATOR+set}" != set; then
12522   echo "#! /bin/sh" >conf$$.sh
12523   echo  "exit 0"   >>conf$$.sh
12524   chmod +x conf$$.sh
12525   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12526     PATH_SEPARATOR=';'
12527   else
12528     PATH_SEPARATOR=:
12529   fi
12530   rm -f conf$$.sh
12531 fi
12532
12533
12534   as_lineno_1=$LINENO
12535   as_lineno_2=$LINENO
12536   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12537   test "x$as_lineno_1" != "x$as_lineno_2" &&
12538   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12539   # Find who we are.  Look in the path if we contain no path at all
12540   # relative or not.
12541   case $0 in
12542     *[\\/]* ) as_myself=$0 ;;
12543     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12544 for as_dir in $PATH
12545 do
12546   IFS=$as_save_IFS
12547   test -z "$as_dir" && as_dir=.
12548   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12549 done
12550
12551        ;;
12552   esac
12553   # We did not find ourselves, most probably we were run as `sh COMMAND'
12554   # in which case we are not to be found in the path.
12555   if test "x$as_myself" = x; then
12556     as_myself=$0
12557   fi
12558   if test ! -f "$as_myself"; then
12559     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12560 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12561    { (exit 1); exit 1; }; }
12562   fi
12563   case $CONFIG_SHELL in
12564   '')
12565     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12566 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12567 do
12568   IFS=$as_save_IFS
12569   test -z "$as_dir" && as_dir=.
12570   for as_base in sh bash ksh sh5; do
12571          case $as_dir in
12572          /*)
12573            if ("$as_dir/$as_base" -c '
12574   as_lineno_1=$LINENO
12575   as_lineno_2=$LINENO
12576   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12577   test "x$as_lineno_1" != "x$as_lineno_2" &&
12578   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12579              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12580              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12581              CONFIG_SHELL=$as_dir/$as_base
12582              export CONFIG_SHELL
12583              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12584            fi;;
12585          esac
12586        done
12587 done
12588 ;;
12589   esac
12590
12591   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12592   # uniformly replaced by the line number.  The first 'sed' inserts a
12593   # line-number line before each line; the second 'sed' does the real
12594   # work.  The second script uses 'N' to pair each line-number line
12595   # with the numbered line, and appends trailing '-' during
12596   # substitution so that $LINENO is not a special case at line end.
12597   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12598   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12599   sed '=' <$as_myself |
12600     sed '
12601       N
12602       s,$,-,
12603       : loop
12604       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12605       t loop
12606       s,-$,,
12607       s,^['$as_cr_digits']*\n,,
12608     ' >$as_me.lineno &&
12609   chmod +x $as_me.lineno ||
12610     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12611 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12612    { (exit 1); exit 1; }; }
12613
12614   # Don't try to exec as it changes $[0], causing all sort of problems
12615   # (the dirname of $[0] is not the place where we might find the
12616   # original and so on.  Autoconf is especially sensible to this).
12617   . ./$as_me.lineno
12618   # Exit status is that of the last command.
12619   exit
12620 }
12621
12622
12623 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12624   *c*,-n*) ECHO_N= ECHO_C='
12625 ' ECHO_T='      ' ;;
12626   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12627   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12628 esac
12629
12630 if expr a : '\(a\)' >/dev/null 2>&1; then
12631   as_expr=expr
12632 else
12633   as_expr=false
12634 fi
12635
12636 rm -f conf$$ conf$$.exe conf$$.file
12637 echo >conf$$.file
12638 if ln -s conf$$.file conf$$ 2>/dev/null; then
12639   # We could just check for DJGPP; but this test a) works b) is more generic
12640   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12641   if test -f conf$$.exe; then
12642     # Don't use ln at all; we don't have any links
12643     as_ln_s='cp -p'
12644   else
12645     as_ln_s='ln -s'
12646   fi
12647 elif ln conf$$.file conf$$ 2>/dev/null; then
12648   as_ln_s=ln
12649 else
12650   as_ln_s='cp -p'
12651 fi
12652 rm -f conf$$ conf$$.exe conf$$.file
12653
12654 if mkdir -p . 2>/dev/null; then
12655   as_mkdir_p=:
12656 else
12657   test -d ./-p && rmdir ./-p
12658   as_mkdir_p=false
12659 fi
12660
12661 as_executable_p="test -f"
12662
12663 # Sed expression to map a string onto a valid CPP name.
12664 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12665
12666 # Sed expression to map a string onto a valid variable name.
12667 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12668
12669
12670 # IFS
12671 # We need space, tab and new line, in precisely that order.
12672 as_nl='
12673 '
12674 IFS="   $as_nl"
12675
12676 # CDPATH.
12677 $as_unset CDPATH
12678
12679 exec 6>&1
12680
12681 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12682 # report actual input values of CONFIG_FILES etc. instead of their
12683 # values after options handling.  Logging --version etc. is OK.
12684 exec 5>>config.log
12685 {
12686   echo
12687   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12688 ## Running $as_me. ##
12689 _ASBOX
12690 } >&5
12691 cat >&5 <<_CSEOF
12692
12693 This file was extended by $as_me, which was
12694 generated by GNU Autoconf 2.59.  Invocation command line was
12695
12696   CONFIG_FILES    = $CONFIG_FILES
12697   CONFIG_HEADERS  = $CONFIG_HEADERS
12698   CONFIG_LINKS    = $CONFIG_LINKS
12699   CONFIG_COMMANDS = $CONFIG_COMMANDS
12700   $ $0 $@
12701
12702 _CSEOF
12703 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12704 echo >&5
12705 _ACEOF
12706
12707 # Files that config.status was made for.
12708 if test -n "$ac_config_files"; then
12709   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12710 fi
12711
12712 if test -n "$ac_config_headers"; then
12713   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12714 fi
12715
12716 if test -n "$ac_config_links"; then
12717   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12718 fi
12719
12720 if test -n "$ac_config_commands"; then
12721   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12722 fi
12723
12724 cat >>$CONFIG_STATUS <<\_ACEOF
12725
12726 ac_cs_usage="\
12727 \`$as_me' instantiates files from templates according to the
12728 current configuration.
12729
12730 Usage: $0 [OPTIONS] [FILE]...
12731
12732   -h, --help       print this help, then exit
12733   -V, --version    print version number, then exit
12734   -q, --quiet      do not print progress messages
12735   -d, --debug      don't remove temporary files
12736       --recheck    update $as_me by reconfiguring in the same conditions
12737   --file=FILE[:TEMPLATE]
12738                    instantiate the configuration file FILE
12739
12740 Configuration files:
12741 $config_files
12742
12743 Report bugs to <bug-autoconf@gnu.org>."
12744 _ACEOF
12745
12746 cat >>$CONFIG_STATUS <<_ACEOF
12747 ac_cs_version="\\
12748 config.status
12749 configured by $0, generated by GNU Autoconf 2.59,
12750   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12751
12752 Copyright (C) 2003 Free Software Foundation, Inc.
12753 This config.status script is free software; the Free Software Foundation
12754 gives unlimited permission to copy, distribute and modify it."
12755 srcdir=$srcdir
12756 INSTALL="$INSTALL"
12757 _ACEOF
12758
12759 cat >>$CONFIG_STATUS <<\_ACEOF
12760 # If no file are specified by the user, then we need to provide default
12761 # value.  By we need to know if files were specified by the user.
12762 ac_need_defaults=:
12763 while test $# != 0
12764 do
12765   case $1 in
12766   --*=*)
12767     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12768     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12769     ac_shift=:
12770     ;;
12771   -*)
12772     ac_option=$1
12773     ac_optarg=$2
12774     ac_shift=shift
12775     ;;
12776   *) # This is not an option, so the user has probably given explicit
12777      # arguments.
12778      ac_option=$1
12779      ac_need_defaults=false;;
12780   esac
12781
12782   case $ac_option in
12783   # Handling of the options.
12784 _ACEOF
12785 cat >>$CONFIG_STATUS <<\_ACEOF
12786   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12787     ac_cs_recheck=: ;;
12788   --version | --vers* | -V )
12789     echo "$ac_cs_version"; exit 0 ;;
12790   --he | --h)
12791     # Conflict between --help and --header
12792     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12793 Try \`$0 --help' for more information." >&5
12794 echo "$as_me: error: ambiguous option: $1
12795 Try \`$0 --help' for more information." >&2;}
12796    { (exit 1); exit 1; }; };;
12797   --help | --hel | -h )
12798     echo "$ac_cs_usage"; exit 0 ;;
12799   --debug | --d* | -d )
12800     debug=: ;;
12801   --file | --fil | --fi | --f )
12802     $ac_shift
12803     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12804     ac_need_defaults=false;;
12805   --header | --heade | --head | --hea )
12806     $ac_shift
12807     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12808     ac_need_defaults=false;;
12809   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12810   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12811     ac_cs_silent=: ;;
12812
12813   # This is an error.
12814   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12815 Try \`$0 --help' for more information." >&5
12816 echo "$as_me: error: unrecognized option: $1
12817 Try \`$0 --help' for more information." >&2;}
12818    { (exit 1); exit 1; }; } ;;
12819
12820   *) ac_config_targets="$ac_config_targets $1" ;;
12821
12822   esac
12823   shift
12824 done
12825
12826 ac_configure_extra_args=
12827
12828 if $ac_cs_silent; then
12829   exec 6>/dev/null
12830   ac_configure_extra_args="$ac_configure_extra_args --silent"
12831 fi
12832
12833 _ACEOF
12834 cat >>$CONFIG_STATUS <<_ACEOF
12835 if \$ac_cs_recheck; then
12836   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12837   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12838 fi
12839
12840 _ACEOF
12841
12842
12843
12844
12845
12846 cat >>$CONFIG_STATUS <<\_ACEOF
12847 for ac_config_target in $ac_config_targets
12848 do
12849   case "$ac_config_target" in
12850   # Handling of arguments.
12851   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12852   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12853 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12854    { (exit 1); exit 1; }; };;
12855   esac
12856 done
12857
12858 # If the user did not use the arguments to specify the items to instantiate,
12859 # then the envvar interface is used.  Set only those that are not.
12860 # We use the long form for the default assignment because of an extremely
12861 # bizarre bug on SunOS 4.1.3.
12862 if $ac_need_defaults; then
12863   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12864 fi
12865
12866 # Have a temporary directory for convenience.  Make it in the build tree
12867 # simply because there is no reason to put it here, and in addition,
12868 # creating and moving files from /tmp can sometimes cause problems.
12869 # Create a temporary directory, and hook for its removal unless debugging.
12870 $debug ||
12871 {
12872   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12873   trap '{ (exit 1); exit 1; }' 1 2 13 15
12874 }
12875
12876 # Create a (secure) tmp directory for tmp files.
12877
12878 {
12879   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12880   test -n "$tmp" && test -d "$tmp"
12881 }  ||
12882 {
12883   tmp=./confstat$$-$RANDOM
12884   (umask 077 && mkdir $tmp)
12885 } ||
12886 {
12887    echo "$me: cannot create a temporary directory in ." >&2
12888    { (exit 1); exit 1; }
12889 }
12890
12891 _ACEOF
12892
12893 cat >>$CONFIG_STATUS <<_ACEOF
12894
12895 #
12896 # CONFIG_FILES section.
12897 #
12898
12899 # No need to generate the scripts if there are no CONFIG_FILES.
12900 # This happens for instance when ./config.status config.h
12901 if test -n "\$CONFIG_FILES"; then
12902   # Protect against being on the right side of a sed subst in config.status.
12903   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12904    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12905 s,@SHELL@,$SHELL,;t t
12906 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12907 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12908 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12909 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12910 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12911 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12912 s,@exec_prefix@,$exec_prefix,;t t
12913 s,@prefix@,$prefix,;t t
12914 s,@program_transform_name@,$program_transform_name,;t t
12915 s,@bindir@,$bindir,;t t
12916 s,@sbindir@,$sbindir,;t t
12917 s,@libexecdir@,$libexecdir,;t t
12918 s,@datadir@,$datadir,;t t
12919 s,@sysconfdir@,$sysconfdir,;t t
12920 s,@sharedstatedir@,$sharedstatedir,;t t
12921 s,@localstatedir@,$localstatedir,;t t
12922 s,@libdir@,$libdir,;t t
12923 s,@includedir@,$includedir,;t t
12924 s,@oldincludedir@,$oldincludedir,;t t
12925 s,@infodir@,$infodir,;t t
12926 s,@mandir@,$mandir,;t t
12927 s,@build_alias@,$build_alias,;t t
12928 s,@host_alias@,$host_alias,;t t
12929 s,@target_alias@,$target_alias,;t t
12930 s,@DEFS@,$DEFS,;t t
12931 s,@ECHO_C@,$ECHO_C,;t t
12932 s,@ECHO_N@,$ECHO_N,;t t
12933 s,@ECHO_T@,$ECHO_T,;t t
12934 s,@LIBS@,$LIBS,;t t
12935 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12936 s,@build@,$build,;t t
12937 s,@build_cpu@,$build_cpu,;t t
12938 s,@build_vendor@,$build_vendor,;t t
12939 s,@build_os@,$build_os,;t t
12940 s,@build_noncanonical@,$build_noncanonical,;t t
12941 s,@host_noncanonical@,$host_noncanonical,;t t
12942 s,@target_noncanonical@,$target_noncanonical,;t t
12943 s,@host@,$host,;t t
12944 s,@host_cpu@,$host_cpu,;t t
12945 s,@host_vendor@,$host_vendor,;t t
12946 s,@host_os@,$host_os,;t t
12947 s,@target@,$target,;t t
12948 s,@target_cpu@,$target_cpu,;t t
12949 s,@target_vendor@,$target_vendor,;t t
12950 s,@target_os@,$target_os,;t t
12951 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12952 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12953 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12954 s,@LN@,$LN,;t t
12955 s,@LN_S@,$LN_S,;t t
12956 s,@build_libsubdir@,$build_libsubdir,;t t
12957 s,@build_subdir@,$build_subdir,;t t
12958 s,@host_subdir@,$host_subdir,;t t
12959 s,@target_subdir@,$target_subdir,;t t
12960 s,@CC@,$CC,;t t
12961 s,@CFLAGS@,$CFLAGS,;t t
12962 s,@LDFLAGS@,$LDFLAGS,;t t
12963 s,@CPPFLAGS@,$CPPFLAGS,;t t
12964 s,@ac_ct_CC@,$ac_ct_CC,;t t
12965 s,@EXEEXT@,$EXEEXT,;t t
12966 s,@OBJEXT@,$OBJEXT,;t t
12967 s,@CXX@,$CXX,;t t
12968 s,@CXXFLAGS@,$CXXFLAGS,;t t
12969 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12970 s,@GNATBIND@,$GNATBIND,;t t
12971 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12972 s,@GNATMAKE@,$GNATMAKE,;t t
12973 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12974 s,@do_compare@,$do_compare,;t t
12975 s,@gmplibs@,$gmplibs,;t t
12976 s,@gmpinc@,$gmpinc,;t t
12977 s,@stage1_languages@,$stage1_languages,;t t
12978 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12979 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12980 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12981 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12982 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12983 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
12984 s,@tooldir@,$tooldir,;t t
12985 s,@build_tooldir@,$build_tooldir,;t t
12986 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12987 s,@GDB_TK@,$GDB_TK,;t t
12988 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12989 s,@build_configargs@,$build_configargs,;t t
12990 s,@build_configdirs@,$build_configdirs,;t t
12991 s,@host_configargs@,$host_configargs,;t t
12992 s,@configdirs@,$configdirs,;t t
12993 s,@target_configargs@,$target_configargs,;t t
12994 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12995 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12996 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12997 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12998 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12999 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13000 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13001 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13002 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13003 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13004 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13005 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13006 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13007 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13008 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13009 s,@config_shell@,$config_shell,;t t
13010 s,@YACC@,$YACC,;t t
13011 s,@BISON@,$BISON,;t t
13012 s,@M4@,$M4,;t t
13013 s,@LEX@,$LEX,;t t
13014 s,@FLEX@,$FLEX,;t t
13015 s,@MAKEINFO@,$MAKEINFO,;t t
13016 s,@EXPECT@,$EXPECT,;t t
13017 s,@RUNTEST@,$RUNTEST,;t t
13018 s,@AR@,$AR,;t t
13019 s,@AS@,$AS,;t t
13020 s,@DLLTOOL@,$DLLTOOL,;t t
13021 s,@LD@,$LD,;t t
13022 s,@LIPO@,$LIPO,;t t
13023 s,@NM@,$NM,;t t
13024 s,@RANLIB@,$RANLIB,;t t
13025 s,@STRIP@,$STRIP,;t t
13026 s,@WINDRES@,$WINDRES,;t t
13027 s,@WINDMC@,$WINDMC,;t t
13028 s,@OBJCOPY@,$OBJCOPY,;t t
13029 s,@OBJDUMP@,$OBJDUMP,;t t
13030 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13031 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13032 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13033 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13034 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13035 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13036 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13037 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13038 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13039 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13040 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13041 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13042 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13043 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13044 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13045 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13046 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13047 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13048 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13049 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13050 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13051 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13052 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13053 s,@MAINT@,$MAINT,;t t
13054 s,@stage1_cflags@,$stage1_cflags,;t t
13055 s,@stage1_checking@,$stage1_checking,;t t
13056 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13057 s,@datarootdir@,$datarootdir,;t t
13058 s,@docdir@,$docdir,;t t
13059 s,@pdfdir@,$pdfdir,;t t
13060 s,@htmldir@,$htmldir,;t t
13061 s,@LIBOBJS@,$LIBOBJS,;t t
13062 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13063 /@serialization_dependencies@/r $serialization_dependencies
13064 s,@serialization_dependencies@,,;t t
13065 /@host_makefile_frag@/r $host_makefile_frag
13066 s,@host_makefile_frag@,,;t t
13067 /@target_makefile_frag@/r $target_makefile_frag
13068 s,@target_makefile_frag@,,;t t
13069 /@alphaieee_frag@/r $alphaieee_frag
13070 s,@alphaieee_frag@,,;t t
13071 /@ospace_frag@/r $ospace_frag
13072 s,@ospace_frag@,,;t t
13073 CEOF
13074
13075 _ACEOF
13076
13077   cat >>$CONFIG_STATUS <<\_ACEOF
13078   # Split the substitutions into bite-sized pieces for seds with
13079   # small command number limits, like on Digital OSF/1 and HP-UX.
13080   ac_max_sed_lines=48
13081   ac_sed_frag=1 # Number of current file.
13082   ac_beg=1 # First line for current file.
13083   ac_end=$ac_max_sed_lines # Line after last line for current file.
13084   ac_more_lines=:
13085   ac_sed_cmds=
13086   while $ac_more_lines; do
13087     if test $ac_beg -gt 1; then
13088       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13089     else
13090       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13091     fi
13092     if test ! -s $tmp/subs.frag; then
13093       ac_more_lines=false
13094     else
13095       # The purpose of the label and of the branching condition is to
13096       # speed up the sed processing (if there are no `@' at all, there
13097       # is no need to browse any of the substitutions).
13098       # These are the two extra sed commands mentioned above.
13099       (echo ':t
13100   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13101       if test -z "$ac_sed_cmds"; then
13102         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13103       else
13104         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13105       fi
13106       ac_sed_frag=`expr $ac_sed_frag + 1`
13107       ac_beg=$ac_end
13108       ac_end=`expr $ac_end + $ac_max_sed_lines`
13109     fi
13110   done
13111   if test -z "$ac_sed_cmds"; then
13112     ac_sed_cmds=cat
13113   fi
13114 fi # test -n "$CONFIG_FILES"
13115
13116 _ACEOF
13117 cat >>$CONFIG_STATUS <<\_ACEOF
13118 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13119   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13120   case $ac_file in
13121   - | *:- | *:-:* ) # input from stdin
13122         cat >$tmp/stdin
13123         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13124         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13125   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13126         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13127   * )   ac_file_in=$ac_file.in ;;
13128   esac
13129
13130   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13131   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13132 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13133          X"$ac_file" : 'X\(//\)[^/]' \| \
13134          X"$ac_file" : 'X\(//\)$' \| \
13135          X"$ac_file" : 'X\(/\)' \| \
13136          .     : '\(.\)' 2>/dev/null ||
13137 echo X"$ac_file" |
13138     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13139           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13140           /^X\(\/\/\)$/{ s//\1/; q; }
13141           /^X\(\/\).*/{ s//\1/; q; }
13142           s/.*/./; q'`
13143   { if $as_mkdir_p; then
13144     mkdir -p "$ac_dir"
13145   else
13146     as_dir="$ac_dir"
13147     as_dirs=
13148     while test ! -d "$as_dir"; do
13149       as_dirs="$as_dir $as_dirs"
13150       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13151 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13152          X"$as_dir" : 'X\(//\)[^/]' \| \
13153          X"$as_dir" : 'X\(//\)$' \| \
13154          X"$as_dir" : 'X\(/\)' \| \
13155          .     : '\(.\)' 2>/dev/null ||
13156 echo X"$as_dir" |
13157     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13158           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13159           /^X\(\/\/\)$/{ s//\1/; q; }
13160           /^X\(\/\).*/{ s//\1/; q; }
13161           s/.*/./; q'`
13162     done
13163     test ! -n "$as_dirs" || mkdir $as_dirs
13164   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13165 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13166    { (exit 1); exit 1; }; }; }
13167
13168   ac_builddir=.
13169
13170 if test "$ac_dir" != .; then
13171   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13172   # A "../" for each directory in $ac_dir_suffix.
13173   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13174 else
13175   ac_dir_suffix= ac_top_builddir=
13176 fi
13177
13178 case $srcdir in
13179   .)  # No --srcdir option.  We are building in place.
13180     ac_srcdir=.
13181     if test -z "$ac_top_builddir"; then
13182        ac_top_srcdir=.
13183     else
13184        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13185     fi ;;
13186   [\\/]* | ?:[\\/]* )  # Absolute path.
13187     ac_srcdir=$srcdir$ac_dir_suffix;
13188     ac_top_srcdir=$srcdir ;;
13189   *) # Relative path.
13190     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13191     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13192 esac
13193
13194 # Do not use `cd foo && pwd` to compute absolute paths, because
13195 # the directories may not exist.
13196 case `pwd` in
13197 .) ac_abs_builddir="$ac_dir";;
13198 *)
13199   case "$ac_dir" in
13200   .) ac_abs_builddir=`pwd`;;
13201   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13202   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13203   esac;;
13204 esac
13205 case $ac_abs_builddir in
13206 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13207 *)
13208   case ${ac_top_builddir}. in
13209   .) ac_abs_top_builddir=$ac_abs_builddir;;
13210   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13211   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13212   esac;;
13213 esac
13214 case $ac_abs_builddir in
13215 .) ac_abs_srcdir=$ac_srcdir;;
13216 *)
13217   case $ac_srcdir in
13218   .) ac_abs_srcdir=$ac_abs_builddir;;
13219   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13220   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13221   esac;;
13222 esac
13223 case $ac_abs_builddir in
13224 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13225 *)
13226   case $ac_top_srcdir in
13227   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13228   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13229   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13230   esac;;
13231 esac
13232
13233
13234   case $INSTALL in
13235   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13236   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13237   esac
13238
13239   if test x"$ac_file" != x-; then
13240     { echo "$as_me:$LINENO: creating $ac_file" >&5
13241 echo "$as_me: creating $ac_file" >&6;}
13242     rm -f "$ac_file"
13243   fi
13244   # Let's still pretend it is `configure' which instantiates (i.e., don't
13245   # use $as_me), people would be surprised to read:
13246   #    /* config.h.  Generated by config.status.  */
13247   if test x"$ac_file" = x-; then
13248     configure_input=
13249   else
13250     configure_input="$ac_file.  "
13251   fi
13252   configure_input=$configure_input"Generated from `echo $ac_file_in |
13253                                      sed 's,.*/,,'` by configure."
13254
13255   # First look for the input files in the build tree, otherwise in the
13256   # src tree.
13257   ac_file_inputs=`IFS=:
13258     for f in $ac_file_in; do
13259       case $f in
13260       -) echo $tmp/stdin ;;
13261       [\\/$]*)
13262          # Absolute (can't be DOS-style, as IFS=:)
13263          test -f "$f" || { { 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          echo "$f";;
13267       *) # Relative
13268          if test -f "$f"; then
13269            # Build tree
13270            echo "$f"
13271          elif test -f "$srcdir/$f"; then
13272            # Source tree
13273            echo "$srcdir/$f"
13274          else
13275            # /dev/null tree
13276            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13277 echo "$as_me: error: cannot find input file: $f" >&2;}
13278    { (exit 1); exit 1; }; }
13279          fi;;
13280       esac
13281     done` || { (exit 1); exit 1; }
13282 _ACEOF
13283 cat >>$CONFIG_STATUS <<_ACEOF
13284   sed "$ac_vpsub
13285 $extrasub
13286 _ACEOF
13287 cat >>$CONFIG_STATUS <<\_ACEOF
13288 :t
13289 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13290 s,@configure_input@,$configure_input,;t t
13291 s,@srcdir@,$ac_srcdir,;t t
13292 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13293 s,@top_srcdir@,$ac_top_srcdir,;t t
13294 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13295 s,@builddir@,$ac_builddir,;t t
13296 s,@abs_builddir@,$ac_abs_builddir,;t t
13297 s,@top_builddir@,$ac_top_builddir,;t t
13298 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13299 s,@INSTALL@,$ac_INSTALL,;t t
13300 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13301   rm -f $tmp/stdin
13302   if test x"$ac_file" != x-; then
13303     mv $tmp/out $ac_file
13304   else
13305     cat $tmp/out
13306     rm -f $tmp/out
13307   fi
13308
13309 done
13310 _ACEOF
13311
13312 cat >>$CONFIG_STATUS <<\_ACEOF
13313
13314 { (exit 0); exit 0; }
13315 _ACEOF
13316 chmod +x $CONFIG_STATUS
13317 ac_clean_files=$ac_clean_files_save
13318
13319
13320 # configure is writing to config.log, and then calls config.status.
13321 # config.status does its own redirection, appending to config.log.
13322 # Unfortunately, on DOS this fails, as config.log is still kept open
13323 # by configure, so config.status won't be able to write to it; its
13324 # output is simply discarded.  So we exec the FD to /dev/null,
13325 # effectively closing config.log, so it can be properly (re)opened and
13326 # appended to by config.status.  When coming back to configure, we
13327 # need to make the FD available again.
13328 if test "$no_create" != yes; then
13329   ac_cs_success=:
13330   ac_config_status_args=
13331   test "$silent" = yes &&
13332     ac_config_status_args="$ac_config_status_args --quiet"
13333   exec 5>/dev/null
13334   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13335   exec 5>>config.log
13336   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13337   # would make configure fail if this is the last instruction.
13338   $ac_cs_success || { (exit 1); exit 1; }
13339 fi
13340