contrib/gcc-4.4/configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc extra_mpfr_configure_flags ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 973                           when linking with PPL
 974   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 975                           Equivalent to --with-ppl-include=PATH/include
 976                           plus --with-ppl-lib=PATH/lib
 977   --with-ppl-include=PATH Specify directory for installed PPL include files
 978   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 979   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 980                           Equivalent to --with-cloog-include=PATH/include
 981                           plus --with-cloog-lib=PATH/lib
 982   --with-cloog-include=PATH Specify directory for installed CLooG include files
 983   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 984   --with-build-sysroot=SYSROOT
 985                           use sysroot as the system root during the build
 986   --with-debug-prefix-map='A=B C=D ...'
 987                              map A to B, C to D ... in debug information
 988   --with-build-time-tools=PATH
 989                           use given path to find target tools during the build
 990   --with-datarootdir      use datarootdir as the data root directory.
 991   --with-docdir           install documentation in this directory.
 992   --with-pdfdir           install pdf in this directory.
 993   --with-htmldir          install html in this directory.
 994
 995 Some influential environment variables:
 996   CC          C compiler command
 997   CFLAGS      C compiler flags
 998   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 999               nonstandard directory <lib dir>
1000   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1001               headers in a nonstandard directory <include dir>
1002   CXX         C++ compiler command
1003   CXXFLAGS    C++ compiler flags
1004   AR          AR for the host
1005   AS          AS for the host
1006   DLLTOOL     DLLTOOL for the host
1007   LD          LD for the host
1008   LIPO        LIPO for the host
1009   NM          NM for the host
1010   RANLIB      RANLIB for the host
1011   STRIP       STRIP for the host
1012   WINDRES     WINDRES for the host
1013   WINDMC      WINDMC for the host
1014   OBJCOPY     OBJCOPY for the host
1015   OBJDUMP     OBJDUMP for the host
1016   CC_FOR_TARGET
1017               CC for the target
1018   CXX_FOR_TARGET
1019               CXX for the target
1020   GCC_FOR_TARGET
1021               GCC for the target
1022   GCJ_FOR_TARGET
1023               GCJ for the target
1024   GFORTRAN_FOR_TARGET
1025               GFORTRAN for the target
1026   AR_FOR_TARGET
1027               AR for the target
1028   AS_FOR_TARGET
1029               AS for the target
1030   DLLTOOL_FOR_TARGET
1031               DLLTOOL for the target
1032   LD_FOR_TARGET
1033               LD for the target
1034   LIPO_FOR_TARGET
1035               LIPO for the target
1036   NM_FOR_TARGET
1037               NM for the target
1038   OBJDUMP_FOR_TARGET
1039               OBJDUMP for the target
1040   RANLIB_FOR_TARGET
1041               RANLIB for the target
1042   STRIP_FOR_TARGET
1043               STRIP for the target
1044   WINDRES_FOR_TARGET
1045               WINDRES for the target
1046   WINDMC_FOR_TARGET
1047               WINDMC for the target
1048
1049 Use these variables to override the choices made by `configure' or to help
1050 it to find libraries and programs with nonstandard names/locations.
1051
1052 _ACEOF
1053 fi
1054
1055 if test "$ac_init_help" = "recursive"; then
1056   # If there are subdirs, report their specific --help.
1057   ac_popdir=`pwd`
1058   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1059     test -d $ac_dir || continue
1060     ac_builddir=.
1061
1062 if test "$ac_dir" != .; then
1063   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1064   # A "../" for each directory in $ac_dir_suffix.
1065   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1066 else
1067   ac_dir_suffix= ac_top_builddir=
1068 fi
1069
1070 case $srcdir in
1071   .)  # No --srcdir option.  We are building in place.
1072     ac_srcdir=.
1073     if test -z "$ac_top_builddir"; then
1074        ac_top_srcdir=.
1075     else
1076        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1077     fi ;;
1078   [\\/]* | ?:[\\/]* )  # Absolute path.
1079     ac_srcdir=$srcdir$ac_dir_suffix;
1080     ac_top_srcdir=$srcdir ;;
1081   *) # Relative path.
1082     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1083     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1084 esac
1085
1086 # Do not use `cd foo && pwd` to compute absolute paths, because
1087 # the directories may not exist.
1088 case `pwd` in
1089 .) ac_abs_builddir="$ac_dir";;
1090 *)
1091   case "$ac_dir" in
1092   .) ac_abs_builddir=`pwd`;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1094   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1099 *)
1100   case ${ac_top_builddir}. in
1101   .) ac_abs_top_builddir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1103   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1104   esac;;
1105 esac
1106 case $ac_abs_builddir in
1107 .) ac_abs_srcdir=$ac_srcdir;;
1108 *)
1109   case $ac_srcdir in
1110   .) ac_abs_srcdir=$ac_abs_builddir;;
1111   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1112   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1113   esac;;
1114 esac
1115 case $ac_abs_builddir in
1116 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1117 *)
1118   case $ac_top_srcdir in
1119   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1120   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1121   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1122   esac;;
1123 esac
1124
1125     cd $ac_dir
1126     # Check for guested configure; otherwise get Cygnus style configure.
1127     if test -f $ac_srcdir/configure.gnu; then
1128       echo
1129       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1130     elif test -f $ac_srcdir/configure; then
1131       echo
1132       $SHELL $ac_srcdir/configure  --help=recursive
1133     elif test -f $ac_srcdir/configure.ac ||
1134            test -f $ac_srcdir/configure.in; then
1135       echo
1136       $ac_configure --help
1137     else
1138       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1139     fi
1140     cd $ac_popdir
1141   done
1142 fi
1143
1144 test -n "$ac_init_help" && exit 0
1145 if $ac_init_version; then
1146   cat <<\_ACEOF
1147
1148 Copyright (C) 2003 Free Software Foundation, Inc.
1149 This configure script is free software; the Free Software Foundation
1150 gives unlimited permission to copy, distribute and modify it.
1151 _ACEOF
1152   exit 0
1153 fi
1154 exec 5>config.log
1155 cat >&5 <<_ACEOF
1156 This file contains any messages produced by compilers while
1157 running configure, to aid debugging if configure makes a mistake.
1158
1159 It was created by $as_me, which was
1160 generated by GNU Autoconf 2.59.  Invocation command line was
1161
1162   $ $0 $@
1163
1164 _ACEOF
1165 {
1166 cat <<_ASUNAME
1167 ## --------- ##
1168 ## Platform. ##
1169 ## --------- ##
1170
1171 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1172 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1173 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1174 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1175 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1176
1177 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1178 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1179
1180 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1181 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1182 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1183 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1184 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1185 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1186 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1187
1188 _ASUNAME
1189
1190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1191 for as_dir in $PATH
1192 do
1193   IFS=$as_save_IFS
1194   test -z "$as_dir" && as_dir=.
1195   echo "PATH: $as_dir"
1196 done
1197
1198 } >&5
1199
1200 cat >&5 <<_ACEOF
1201
1202
1203 ## ----------- ##
1204 ## Core tests. ##
1205 ## ----------- ##
1206
1207 _ACEOF
1208
1209
1210 # Keep a trace of the command line.
1211 # Strip out --no-create and --no-recursion so they do not pile up.
1212 # Strip out --silent because we don't want to record it for future runs.
1213 # Also quote any args containing shell meta-characters.
1214 # Make two passes to allow for proper duplicate-argument suppression.
1215 ac_configure_args=
1216 ac_configure_args0=
1217 ac_configure_args1=
1218 ac_sep=
1219 ac_must_keep_next=false
1220 for ac_pass in 1 2
1221 do
1222   for ac_arg
1223   do
1224     case $ac_arg in
1225     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1226     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1227     | -silent | --silent | --silen | --sile | --sil)
1228       continue ;;
1229     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1230       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1231     esac
1232     case $ac_pass in
1233     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1234     2)
1235       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1236       if test $ac_must_keep_next = true; then
1237         ac_must_keep_next=false # Got value, back to normal.
1238       else
1239         case $ac_arg in
1240           *=* | --config-cache | -C | -disable-* | --disable-* \
1241           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1242           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1243           | -with-* | --with-* | -without-* | --without-* | --x)
1244             case "$ac_configure_args0 " in
1245               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1246             esac
1247             ;;
1248           -* ) ac_must_keep_next=true ;;
1249         esac
1250       fi
1251       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1252       # Get rid of the leading space.
1253       ac_sep=" "
1254       ;;
1255     esac
1256   done
1257 done
1258 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1259 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1260
1261 # When interrupted or exit'd, cleanup temporary files, and complete
1262 # config.log.  We remove comments because anyway the quotes in there
1263 # would cause problems or look ugly.
1264 # WARNING: Be sure not to use single quotes in there, as some shells,
1265 # such as our DU 5.0 friend, will then `close' the trap.
1266 trap 'exit_status=$?
1267   # Save into config.log some information that might help in debugging.
1268   {
1269     echo
1270
1271     cat <<\_ASBOX
1272 ## ---------------- ##
1273 ## Cache variables. ##
1274 ## ---------------- ##
1275 _ASBOX
1276     echo
1277     # The following way of writing the cache mishandles newlines in values,
1278 {
1279   (set) 2>&1 |
1280     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1281     *ac_space=\ *)
1282       sed -n \
1283         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1284           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1285       ;;
1286     *)
1287       sed -n \
1288         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1289       ;;
1290     esac;
1291 }
1292     echo
1293
1294     cat <<\_ASBOX
1295 ## ----------------- ##
1296 ## Output variables. ##
1297 ## ----------------- ##
1298 _ASBOX
1299     echo
1300     for ac_var in $ac_subst_vars
1301     do
1302       eval ac_val=$`echo $ac_var`
1303       echo "$ac_var='"'"'$ac_val'"'"'"
1304     done | sort
1305     echo
1306
1307     if test -n "$ac_subst_files"; then
1308       cat <<\_ASBOX
1309 ## ------------- ##
1310 ## Output files. ##
1311 ## ------------- ##
1312 _ASBOX
1313       echo
1314       for ac_var in $ac_subst_files
1315       do
1316         eval ac_val=$`echo $ac_var`
1317         echo "$ac_var='"'"'$ac_val'"'"'"
1318       done | sort
1319       echo
1320     fi
1321
1322     if test -s confdefs.h; then
1323       cat <<\_ASBOX
1324 ## ----------- ##
1325 ## confdefs.h. ##
1326 ## ----------- ##
1327 _ASBOX
1328       echo
1329       sed "/^$/d" confdefs.h | sort
1330       echo
1331     fi
1332     test "$ac_signal" != 0 &&
1333       echo "$as_me: caught signal $ac_signal"
1334     echo "$as_me: exit $exit_status"
1335   } >&5
1336   rm -f core *.core &&
1337   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1338     exit $exit_status
1339      ' 0
1340 for ac_signal in 1 2 13 15; do
1341   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1342 done
1343 ac_signal=0
1344
1345 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1346 rm -rf conftest* confdefs.h
1347 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1348 echo >confdefs.h
1349
1350 # Predefined preprocessor variables.
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_NAME "$PACKAGE_NAME"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1359 _ACEOF
1360
1361
1362 cat >>confdefs.h <<_ACEOF
1363 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1364 _ACEOF
1365
1366
1367 cat >>confdefs.h <<_ACEOF
1368 #define PACKAGE_STRING "$PACKAGE_STRING"
1369 _ACEOF
1370
1371
1372 cat >>confdefs.h <<_ACEOF
1373 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1374 _ACEOF
1375
1376
1377 # Let the site file select an alternate cache file if it wants to.
1378 # Prefer explicitly selected file to automatically selected ones.
1379 if test -z "$CONFIG_SITE"; then
1380   if test "x$prefix" != xNONE; then
1381     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1382   else
1383     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1384   fi
1385 fi
1386 for ac_site_file in $CONFIG_SITE; do
1387   if test -r "$ac_site_file"; then
1388     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1389 echo "$as_me: loading site script $ac_site_file" >&6;}
1390     sed 's/^/| /' "$ac_site_file" >&5
1391     . "$ac_site_file"
1392   fi
1393 done
1394
1395 if test -r "$cache_file"; then
1396   # Some versions of bash will fail to source /dev/null (special
1397   # files actually), so we avoid doing that.
1398   if test -f "$cache_file"; then
1399     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1400 echo "$as_me: loading cache $cache_file" >&6;}
1401     case $cache_file in
1402       [\\/]* | ?:[\\/]* ) . $cache_file;;
1403       *)                      . ./$cache_file;;
1404     esac
1405   fi
1406 else
1407   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1408 echo "$as_me: creating cache $cache_file" >&6;}
1409   >$cache_file
1410 fi
1411
1412 # Check that the precious variables saved in the cache have kept the same
1413 # value.
1414 ac_cache_corrupted=false
1415 for ac_var in `(set) 2>&1 |
1416                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1417   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1418   eval ac_new_set=\$ac_env_${ac_var}_set
1419   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1420   eval ac_new_val="\$ac_env_${ac_var}_value"
1421   case $ac_old_set,$ac_new_set in
1422     set,)
1423       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1424 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1425       ac_cache_corrupted=: ;;
1426     ,set)
1427       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1428 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1429       ac_cache_corrupted=: ;;
1430     ,);;
1431     *)
1432       if test "x$ac_old_val" != "x$ac_new_val"; then
1433         # differences in whitespace do not lead to failure.
1434         ac_old_val_w=`echo x $ac_old_val`
1435         ac_new_val_w=`echo x $ac_new_val`
1436         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1437           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1438 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1439           ac_cache_corrupted=:
1440         else
1441           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1442 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1443           eval $ac_var=\$ac_old_val
1444         fi
1445         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1446 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1447         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1448 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1449       fi;;
1450   esac
1451   # Pass precious variables to config.status.
1452   if test "$ac_new_set" = set; then
1453     case $ac_new_val in
1454     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1455       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1456     *) ac_arg=$ac_var=$ac_new_val ;;
1457     esac
1458     case " $ac_configure_args " in
1459       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1460       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1461     esac
1462   fi
1463 done
1464 if $ac_cache_corrupted; then
1465   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1466 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1467   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1468 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1469   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1470 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1471    { (exit 1); exit 1; }; }
1472 fi
1473
1474 ac_ext=c
1475 ac_cpp='$CPP $CPPFLAGS'
1476 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1477 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1478 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503 progname=$0
1504 # if PWD already has a value, it is probably wrong.
1505 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1506
1507 # Export original configure arguments for use by sub-configures.
1508 # Quote arguments with shell meta charatcers.
1509 TOPLEVEL_CONFIGURE_ARGUMENTS=
1510 set -- "$progname" "$@"
1511 for ac_arg
1512 do
1513   case "$ac_arg" in
1514   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1515     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1516     # if the argument is of the form -foo=baz, quote the baz part only
1517     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1518   *) ;;
1519   esac
1520   # Add the quoted argument to the list.
1521   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1522 done
1523 if test "$silent" = yes; then
1524   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1525 fi
1526 # Remove the initial space we just introduced and, as these will be
1527 # expanded by make, quote '$'.
1528 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1529
1530
1531 # Find the build, host, and target systems.
1532 ac_aux_dir=
1533 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1534   if test -f $ac_dir/install-sh; then
1535     ac_aux_dir=$ac_dir
1536     ac_install_sh="$ac_aux_dir/install-sh -c"
1537     break
1538   elif test -f $ac_dir/install.sh; then
1539     ac_aux_dir=$ac_dir
1540     ac_install_sh="$ac_aux_dir/install.sh -c"
1541     break
1542   elif test -f $ac_dir/shtool; then
1543     ac_aux_dir=$ac_dir
1544     ac_install_sh="$ac_aux_dir/shtool install -c"
1545     break
1546   fi
1547 done
1548 if test -z "$ac_aux_dir"; then
1549   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1550 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1551    { (exit 1); exit 1; }; }
1552 fi
1553 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1554 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1555 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1556
1557 # Make sure we can run config.sub.
1558 $ac_config_sub sun4 >/dev/null 2>&1 ||
1559   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1560 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1561    { (exit 1); exit 1; }; }
1562
1563 echo "$as_me:$LINENO: checking build system type" >&5
1564 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1565 if test "${ac_cv_build+set}" = set; then
1566   echo $ECHO_N "(cached) $ECHO_C" >&6
1567 else
1568   ac_cv_build_alias=$build_alias
1569 test -z "$ac_cv_build_alias" &&
1570   ac_cv_build_alias=`$ac_config_guess`
1571 test -z "$ac_cv_build_alias" &&
1572   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1573 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1574    { (exit 1); exit 1; }; }
1575 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1576   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1577 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1578    { (exit 1); exit 1; }; }
1579
1580 fi
1581 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1582 echo "${ECHO_T}$ac_cv_build" >&6
1583 build=$ac_cv_build
1584 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1585 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1586 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1587
1588
1589  case ${build_alias} in
1590   "") build_noncanonical=${build} ;;
1591   *) build_noncanonical=${build_alias} ;;
1592 esac
1593
1594
1595
1596  case ${host_alias} in
1597   "") host_noncanonical=${build_noncanonical} ;;
1598   *) host_noncanonical=${host_alias} ;;
1599 esac
1600
1601
1602
1603  case ${target_alias} in
1604   "") target_noncanonical=${host_noncanonical} ;;
1605   *) target_noncanonical=${target_alias} ;;
1606 esac
1607
1608
1609
1610
1611 test "$host_noncanonical" = "$target_noncanonical" &&
1612   test "$program_prefix$program_suffix$program_transform_name" = \
1613     NONENONEs,x,x, &&
1614   program_transform_name=s,y,y,
1615
1616 echo "$as_me:$LINENO: checking host system type" >&5
1617 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1618 if test "${ac_cv_host+set}" = set; then
1619   echo $ECHO_N "(cached) $ECHO_C" >&6
1620 else
1621   ac_cv_host_alias=$host_alias
1622 test -z "$ac_cv_host_alias" &&
1623   ac_cv_host_alias=$ac_cv_build_alias
1624 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1625   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1626 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1627    { (exit 1); exit 1; }; }
1628
1629 fi
1630 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1631 echo "${ECHO_T}$ac_cv_host" >&6
1632 host=$ac_cv_host
1633 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1634 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1635 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1636
1637
1638 echo "$as_me:$LINENO: checking target system type" >&5
1639 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1640 if test "${ac_cv_target+set}" = set; then
1641   echo $ECHO_N "(cached) $ECHO_C" >&6
1642 else
1643   ac_cv_target_alias=$target_alias
1644 test "x$ac_cv_target_alias" = "x" &&
1645   ac_cv_target_alias=$ac_cv_host_alias
1646 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1647   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1648 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1649    { (exit 1); exit 1; }; }
1650
1651 fi
1652 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1653 echo "${ECHO_T}$ac_cv_target" >&6
1654 target=$ac_cv_target
1655 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1656 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1657 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1658
1659
1660 # The aliases save the names the user supplied, while $host etc.
1661 # will get canonicalized.
1662 test -n "$target_alias" &&
1663   test "$program_prefix$program_suffix$program_transform_name" = \
1664     NONENONEs,x,x, &&
1665   program_prefix=${target_alias}-
1666 test "$program_prefix" != NONE &&
1667   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1668 # Use a double $ so make ignores it.
1669 test "$program_suffix" != NONE &&
1670   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1671 # Double any \ or $.  echo might interpret backslashes.
1672 # By default was `s,x,x', remove it if useless.
1673 cat <<\_ACEOF >conftest.sed
1674 s/[\\$]/&&/g;s/;s,x,x,$//
1675 _ACEOF
1676 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1677 rm conftest.sed
1678
1679
1680
1681 # Get 'install' or 'install-sh' and its variants.
1682 # Find a good install program.  We prefer a C program (faster),
1683 # so one script is as good as another.  But avoid the broken or
1684 # incompatible versions:
1685 # SysV /etc/install, /usr/sbin/install
1686 # SunOS /usr/etc/install
1687 # IRIX /sbin/install
1688 # AIX /bin/install
1689 # AmigaOS /C/install, which installs bootblocks on floppy discs
1690 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1691 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1692 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1693 # OS/2's system install, which has a completely different semantic
1694 # ./install, which can be erroneously created by make from ./install.sh.
1695 # Reject install programs that cannot install multiple files.
1696 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1697 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1698 if test -z "$INSTALL"; then
1699 if test "${ac_cv_path_install+set}" = set; then
1700   echo $ECHO_N "(cached) $ECHO_C" >&6
1701 else
1702   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1703 for as_dir in $PATH
1704 do
1705   IFS=$as_save_IFS
1706   test -z "$as_dir" && as_dir=.
1707   # Account for people who put trailing slashes in PATH elements.
1708 case $as_dir/ in
1709   ./ | .// | /cC/* | \
1710   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1711   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1712   /usr/ucb/* ) ;;
1713   *)
1714     # OSF1 and SCO ODT 3.0 have their own names for install.
1715     # Don't use installbsd from OSF since it installs stuff as root
1716     # by default.
1717     for ac_prog in ginstall scoinst install; do
1718       for ac_exec_ext in '' $ac_executable_extensions; do
1719         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1720           if test $ac_prog = install &&
1721             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1722             # AIX install.  It has an incompatible calling convention.
1723             :
1724           elif test $ac_prog = install &&
1725             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1726             # program-specific install script used by HP pwplus--don't use.
1727             :
1728           else
1729             rm -rf conftest.one conftest.two conftest.dir
1730             echo one > conftest.one
1731             echo two > conftest.two
1732             mkdir conftest.dir
1733             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1734               test -s conftest.one && test -s conftest.two &&
1735               test -s conftest.dir/conftest.one &&
1736               test -s conftest.dir/conftest.two
1737             then
1738               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1739               break 3
1740             fi
1741           fi
1742         fi
1743       done
1744     done
1745     ;;
1746 esac
1747 done
1748
1749 rm -rf conftest.one conftest.two conftest.dir
1750
1751 fi
1752   if test "${ac_cv_path_install+set}" = set; then
1753     INSTALL=$ac_cv_path_install
1754   else
1755     # As a last resort, use the slow shell script.  Don't cache a
1756     # value for INSTALL within a source directory, because that will
1757     # break other packages using the cache if that directory is
1758     # removed, or if the value is a relative name.
1759     INSTALL=$ac_install_sh
1760   fi
1761 fi
1762 echo "$as_me:$LINENO: result: $INSTALL" >&5
1763 echo "${ECHO_T}$INSTALL" >&6
1764
1765 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1766 # It thinks the first close brace ends the variable substitution.
1767 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1768
1769 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1770
1771 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1772
1773 echo "$as_me:$LINENO: checking whether ln works" >&5
1774 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1775 if test "${acx_cv_prog_LN+set}" = set; then
1776   echo $ECHO_N "(cached) $ECHO_C" >&6
1777 else
1778   rm -f conftestdata_t
1779 echo >conftestdata_f
1780 if ln conftestdata_f conftestdata_t 2>/dev/null
1781 then
1782   acx_cv_prog_LN=ln
1783 else
1784   acx_cv_prog_LN=no
1785 fi
1786 rm -f conftestdata_f conftestdata_t
1787
1788 fi
1789 if test $acx_cv_prog_LN = no; then
1790   LN="cp"
1791   echo "$as_me:$LINENO: result: no, using $LN" >&5
1792 echo "${ECHO_T}no, using $LN" >&6
1793 else
1794   LN="$acx_cv_prog_LN"
1795   echo "$as_me:$LINENO: result: yes" >&5
1796 echo "${ECHO_T}yes" >&6
1797 fi
1798
1799 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1800 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1801 LN_S=$as_ln_s
1802 if test "$LN_S" = "ln -s"; then
1803   echo "$as_me:$LINENO: result: yes" >&5
1804 echo "${ECHO_T}yes" >&6
1805 else
1806   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1807 echo "${ECHO_T}no, using $LN_S" >&6
1808 fi
1809
1810
1811 ### we might need to use some other shell than /bin/sh for running subshells
1812 ### If we are on Windows, search for the shell.  This will permit people
1813 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1814 ### without also having to set CONFIG_SHELL.  This code will work when
1815 ### using bash, which sets OSTYPE.
1816 case "${OSTYPE}" in
1817 *win32*)
1818   if test x${CONFIG_SHELL} = x ; then
1819     if test ! -f /bin/sh ; then
1820       if test x${SHELL} != x && test -f ${SHELL} ; then
1821         CONFIG_SHELL=${SHELL}
1822         export CONFIG_SHELL
1823       else
1824         for prog in sh sh.exe bash bash.exe; do
1825           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1826           for dir in $PATH; do
1827             test -z "$dir" && dir=.
1828             if test -f $dir/$prog; then
1829               CONFIG_SHELL=$dir/$prog
1830               export CONFIG_SHELL
1831               break
1832             fi
1833           done
1834           IFS="$save_ifs"
1835           test -n "${CONFIG_SHELL}" && break
1836         done
1837       fi
1838     fi
1839   fi
1840   ;;
1841 esac
1842
1843 config_shell=${CONFIG_SHELL-/bin/sh}
1844
1845 moveifchange=${srcdir}/move-if-change
1846
1847 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1848
1849 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1850 # a relative path.
1851 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1852   INSTALL="${srcpwd}/install-sh -c"
1853 fi
1854
1855 # Set srcdir to "." if that's what it is.
1856 # This is important for multilib support.
1857 pwd=`${PWDCMD-pwd}`
1858 if test "${pwd}" = "${srcpwd}" ; then
1859   srcdir=.
1860 fi
1861
1862 topsrcdir=$srcpwd
1863
1864 extra_host_args=
1865
1866 ### To add a new directory to the tree, first choose whether it is a target
1867 ### or a host dependent tool.  Then put it into the appropriate list
1868 ### (library or tools, host or target), doing a dependency sort.
1869
1870 # Subdirs will be configured in the order listed in build_configdirs,
1871 # configdirs, or target_configdirs; see the serialization section below.
1872
1873 # Dependency sorting is only needed when *configuration* must be done in
1874 # a particular order.  In all cases a dependency should be specified in
1875 # the Makefile, whether or not it's implicitly specified here.
1876
1877 # Double entries in build_configdirs, configdirs, or target_configdirs may
1878 # cause circular dependencies and break everything horribly.
1879
1880 # these library is used by various programs built for the build
1881 # environment
1882 #
1883 build_libs="build-libiberty"
1884
1885 # these tools are built for the build environment
1886 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1887
1888 # these libraries are used by various programs built for the host environment
1889 #
1890 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog libiconv"
1891
1892 # these tools are built for the host environment
1893 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1894 # know that we are building the simulator.
1895 # binutils, gas and ld appear in that order because it makes sense to run
1896 # "make check" in that particular order.
1897 # If --enable-gold is used, "gold" will replace "ld".
1898 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"
1899
1900 # libgcj represents the runtime libraries only used by gcj.
1901 libgcj="target-libffi \
1902         target-zlib \
1903         target-qthreads \
1904         target-libjava"
1905
1906 # these libraries are built for the target environment, and are built after
1907 # the host libraries and the host tools (which may be a cross compiler)
1908 #
1909 target_libraries="target-libgcc \
1910                 target-libiberty \
1911                 target-libgloss \
1912                 target-newlib \
1913                 target-libgomp \
1914                 target-libstdc++-v3 \
1915                 target-libmudflap \
1916                 target-libssp \
1917                 target-libgfortran \
1918                 target-boehm-gc \
1919                 ${libgcj} \
1920                 target-libobjc \
1921                 target-libada"
1922
1923 # these tools are built using the target libraries, and are intended to
1924 # run only in the target environment
1925 #
1926 # note: any program that *uses* libraries that are in the "target_libraries"
1927 # list belongs in this list.  those programs are also very likely
1928 # candidates for the "native_only" list which follows
1929 #
1930 target_tools="target-examples target-groff target-gperf target-rda"
1931
1932 ################################################################################
1933
1934 ## All tools belong in one of the four categories, and are assigned above
1935 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1936 ## is important because configure will choke if they ever get through.
1937 ## ${configdirs} is directories we build using the host tools.
1938 ## ${target_configdirs} is directories we build using the target tools.
1939 configdirs=`echo ${host_libs} ${host_tools}`
1940 target_configdirs=`echo ${target_libraries} ${target_tools}`
1941 build_configdirs=`echo ${build_libs} ${build_tools}`
1942
1943
1944
1945 ################################################################################
1946
1947 srcname="gnu development package"
1948
1949 # This gets set non-empty for some net releases of packages.
1950 appdirs=""
1951
1952 # Define is_cross_compiler to save on calls to 'test'.
1953 is_cross_compiler=
1954 if test x"${host}" = x"${target}" ; then
1955   is_cross_compiler=no
1956 else
1957   is_cross_compiler=yes
1958 fi
1959
1960 # Find the build and target subdir names.
1961
1962 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1963 # have matching libraries, they should use host libraries: Makefile.tpl
1964 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1965 # However, they still use the build modules, because the corresponding
1966 # host modules (e.g. bison) are only built for the host when bootstrap
1967 # finishes. So:
1968 # - build_subdir is where we find build modules, and never changes.
1969 # - build_libsubdir is where we find build libraries, and can be overridden.
1970
1971 # Prefix 'build-' so this never conflicts with target_subdir.
1972 build_subdir="build-${build_noncanonical}"
1973
1974 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1975 if test "${with_build_libsubdir+set}" = set; then
1976   withval="$with_build_libsubdir"
1977   build_libsubdir="$withval"
1978 else
1979   build_libsubdir="$build_subdir"
1980 fi;
1981 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1982 if ( test $srcdir = . && test -d gcc ) \
1983    || test -d $srcdir/../host-${host_noncanonical}; then
1984   host_subdir="host-${host_noncanonical}"
1985 else
1986   host_subdir=.
1987 fi
1988 # No prefix.
1989 target_subdir=${target_noncanonical}
1990
1991
1992 # Skipdirs are removed silently.
1993 skipdirs=
1994 # Noconfigdirs are removed loudly.
1995 noconfigdirs=""
1996
1997 use_gnu_ld=
1998 # Make sure we don't let GNU ld be added if we didn't want it.
1999 if test x$with_gnu_ld = xno ; then
2000   use_gnu_ld=no
2001   noconfigdirs="$noconfigdirs ld gold"
2002 fi
2003
2004 use_gnu_as=
2005 # Make sure we don't let GNU as be added if we didn't want it.
2006 if test x$with_gnu_as = xno ; then
2007   use_gnu_as=no
2008   noconfigdirs="$noconfigdirs gas"
2009 fi
2010
2011 # some tools are so dependent upon X11 that if we're not building with X,
2012 # it's not even worth trying to configure, much less build, that tool.
2013
2014 case ${with_x} in
2015   yes | "") ;; # the default value for this tree is that X11 is available
2016   no)
2017     skipdirs="${skipdirs} tk itcl libgui"
2018     # We won't be able to build gdbtk without X.
2019     enable_gdbtk=no
2020     ;;
2021   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2022 esac
2023
2024 # Some tools are only suitable for building in a "native" situation.
2025 # Remove these if host!=target.
2026 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"
2027
2028 # Similarly, some are only suitable for cross toolchains.
2029 # Remove these if host=target.
2030 cross_only="target-libgloss target-newlib target-opcodes"
2031
2032 case $is_cross_compiler in
2033   no) skipdirs="${skipdirs} ${cross_only}" ;;
2034   yes) skipdirs="${skipdirs} ${native_only}" ;;
2035 esac
2036
2037 # If both --with-headers and --with-libs are specified, default to
2038 # --without-newlib.
2039 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2040    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2041   if test x"${with_newlib}" = x ; then
2042     with_newlib=no
2043   fi
2044 fi
2045
2046 # Recognize --with-newlib/--without-newlib.
2047 case ${with_newlib} in
2048   no) skipdirs="${skipdirs} target-newlib" ;;
2049   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2050 esac
2051
2052 # Handle --enable-gold.
2053
2054 # Check whether --enable-gold or --disable-gold was given.
2055 if test "${enable_gold+set}" = set; then
2056   enableval="$enable_gold"
2057   ENABLE_GOLD=$enableval
2058 else
2059   ENABLE_GOLD=no
2060 fi;
2061 if test "${ENABLE_GOLD}" = "yes"; then
2062   # Check for ELF target.
2063   is_elf=no
2064   case "${target}" in
2065     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2066     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2067     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2068       case "${target}" in
2069         *-*-linux*aout* | *-*-linux*oldld*)
2070           ;;
2071         *)
2072           is_elf=yes
2073           ;;
2074       esac
2075   esac
2076
2077   if test "$is_elf" = "yes"; then
2078     # Check for target supported by gold.
2079     case "${target}" in
2080       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2081         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2082         ;;
2083     esac
2084   fi
2085 fi
2086
2087 # Configure extra directories which are host specific
2088
2089 case "${host}" in
2090   *-cygwin*)
2091     configdirs="$configdirs libtermcap" ;;
2092 esac
2093
2094 # A target can indicate whether a language isn't supported for some reason.
2095 # Only spaces may be used in this macro; not newlines or tabs.
2096 unsupported_languages=
2097
2098 # Remove more programs from consideration, based on the host or
2099 # target this usually means that a port of the program doesn't
2100 # exist yet.
2101
2102 case "${host}" in
2103   hppa*64*-*-*)
2104     noconfigdirs="$noconfigdirs byacc"
2105     ;;
2106   i[3456789]86-*-vsta)
2107     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2108     ;;
2109   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2110     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2111     ;;
2112   x86_64-*-mingw*)
2113     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2114     ;;
2115   i[3456789]86-*-mingw32*)
2116     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2117     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2118     ;;
2119   i[3456789]86-*-beos*)
2120     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2121     ;;
2122   *-*-cygwin*)
2123     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2124     ;;
2125   *-*-netbsd*)
2126     noconfigdirs="$noconfigdirs rcs"
2127     ;;
2128   ppc*-*-pe)
2129     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2130     ;;
2131   powerpc-*-beos*)
2132     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2133     ;;
2134 esac
2135
2136
2137 # Check whether --enable-libada or --disable-libada was given.
2138 if test "${enable_libada+set}" = set; then
2139   enableval="$enable_libada"
2140   ENABLE_LIBADA=$enableval
2141 else
2142   ENABLE_LIBADA=yes
2143 fi;
2144 if test "${ENABLE_LIBADA}" != "yes" ; then
2145   noconfigdirs="$noconfigdirs gnattools"
2146 fi
2147
2148 # Check whether --enable-libssp or --disable-libssp was given.
2149 if test "${enable_libssp+set}" = set; then
2150   enableval="$enable_libssp"
2151   ENABLE_LIBSSP=$enableval
2152 else
2153   ENABLE_LIBSSP=yes
2154 fi;
2155
2156 # Save it here so that, even in case of --enable-libgcj, if the Java
2157 # front-end isn't enabled, we still get libgcj disabled.
2158 libgcj_saved=$libgcj
2159 case $enable_libgcj in
2160 yes)
2161   # If we reset it here, it won't get added to noconfigdirs in the
2162   # target-specific build rules, so it will be forcibly enabled
2163   # (unless the Java language itself isn't enabled).
2164   libgcj=
2165   ;;
2166 no)
2167   # Make sure we get it printed in the list of not supported target libs.
2168   noconfigdirs="$noconfigdirs ${libgcj}"
2169   ;;
2170 esac
2171
2172
2173 # Disable libmudflap on some systems.
2174 if test x$enable_libmudflap = x ; then
2175     case "${target}" in
2176     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2177         # Enable libmudflap by default in GNU and friends.
2178         ;;
2179     *-*-freebsd*)
2180         # Enable libmudflap by default in FreeBSD.
2181         ;;
2182     *)
2183         # Disable it by default everywhere else.
2184         noconfigdirs="$noconfigdirs target-libmudflap"
2185         ;;
2186     esac
2187 fi
2188
2189 # Disable libgomp on non POSIX hosted systems.
2190 if test x$enable_libgomp = x ; then
2191     # Enable libgomp by default on hosted POSIX systems.
2192     case "${target}" in
2193     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2194         ;;
2195     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2196         ;;
2197     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2198         ;;
2199     *-*-darwin* | *-*-aix*)
2200         ;;
2201     *)
2202         noconfigdirs="$noconfigdirs target-libgomp"
2203         ;;
2204     esac
2205 fi
2206
2207 # Default libgloss CPU subdirectory.
2208 libgloss_dir="$target_cpu"
2209
2210 case "${target}" in
2211   *-*-chorusos)
2212     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2213     ;;
2214   powerpc-*-darwin*)
2215     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2216     noconfigdirs="$noconfigdirs sim target-rda"
2217     ;;
2218   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2219     noconfigdirs="$noconfigdirs ld gas gprof"
2220     noconfigdirs="$noconfigdirs sim target-rda"
2221     ;;
2222   *-*-darwin*)
2223     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2224     noconfigdirs="$noconfigdirs sim target-rda"
2225     noconfigdirs="$noconfigdirs ${libgcj}"
2226     ;;
2227   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2228     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2229     ;;
2230   *-*-freebsd*)
2231     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2232     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2233         && test -f /usr/local/include/gmp.h; then
2234       with_gmp=/usr/local
2235     fi
2236
2237     # Skip some stuff that's unsupported on some FreeBSD configurations.
2238     case "${target}" in
2239       i*86-*-*) ;;
2240       alpha*-*-*) ;;
2241       *)
2242         noconfigdirs="$noconfigdirs ${libgcj}"
2243         ;;
2244     esac
2245     ;;
2246   *-*-kaos*)
2247     # Remove unsupported stuff on all kaOS configurations.
2248     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2249     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2250     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2251     noconfigdirs="$noconfigdirs target-libgloss"
2252     ;;
2253   *-*-netbsd*)
2254     # Skip some stuff on all NetBSD configurations.
2255     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2256
2257     # Skip some stuff that's unsupported on some NetBSD configurations.
2258     case "${target}" in
2259       i*86-*-netbsdelf*) ;;
2260       arm*-*-netbsdelf*) ;;
2261       *)
2262         noconfigdirs="$noconfigdirs ${libgcj}"
2263         ;;
2264     esac
2265     ;;
2266   *-*-netware*)
2267     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2268     ;;
2269   *-*-rtems*)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272     # The tpf target doesn't support gdb yet.
2273   *-*-tpf*)
2274     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2275     ;;
2276   *-*-uclinux*)
2277     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2278     ;;
2279   *-*-vxworks*)
2280     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2281     ;;
2282   alpha*-dec-osf*)
2283     # ld works, but does not support shared libraries.
2284     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2285     # gas doesn't generate exception information.
2286     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2287     ;;
2288   alpha*-*-*vms*)
2289     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2290     ;;
2291   alpha*-*-linux*)
2292     # newlib is not 64 bit ready
2293     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2294     ;;
2295   alpha*-*-*)
2296     # newlib is not 64 bit ready
2297     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2298     ;;
2299   am33_2.0-*-linux*)
2300     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2301     ;;
2302   sh-*-linux*)
2303     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2304     ;;
2305   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2306     noconfigdirs="$noconfigdirs ${libgcj}"
2307     noconfigdirs="$noconfigdirs target-examples"
2308     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2309     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2310     noconfigdirs="$noconfigdirs expect dejagnu"
2311     # the C++ libraries don't build on top of CE's C libraries
2312     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2313     noconfigdirs="$noconfigdirs target-newlib"
2314     case "${host}" in
2315       *-*-cygwin*) ;; # keep gdb and readline
2316       *) noconfigdirs="$noconfigdirs gdb readline"
2317          ;;
2318     esac
2319     libgloss_dir=wince
2320     ;;
2321   arc-*-*)
2322     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2323     ;;
2324   arm-semi-aof )
2325     ;;
2326   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2327     noconfigdirs="$noconfigdirs ${libgcj}"
2328     libgloss_dir=arm
2329     ;;
2330   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2331     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2332     libgloss_dir=arm
2333     ;;
2334   arm*-*-linux-gnueabi)
2335     noconfigdirs="$noconfigdirs target-qthreads"
2336     case ${with_newlib} in
2337       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2338     esac
2339     libgloss_dir=arm
2340     ;;
2341   arm*-*-symbianelf*)
2342     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2343     libgloss_dir=arm
2344     ;;
2345   arm-*-pe*)
2346     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2347     ;;
2348   thumb-*-coff)
2349     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2350     ;;
2351   thumb-*-elf)
2352     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2353     ;;
2354   thumb-*-pe)
2355     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2356     ;;
2357   arm-*-riscix*)
2358     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2359     ;;
2360   avr-*-*)
2361     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2362     ;;
2363   bfin-*-*)
2364     noconfigdirs="$noconfigdirs gdb"
2365     if test x${is_cross_compiler} != xno ; then
2366       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2367     fi
2368     ;;
2369   c4x-*-* | tic4x-*-*)
2370     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2371     ;;
2372   c54x*-*-* | tic54x-*-*)
2373     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2374     ;;
2375   cr16-*-*)
2376     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2377     ;;
2378   cris-*-* | crisv32-*-*)
2379     unsupported_languages="$unsupported_languages java"
2380     case "${target}" in
2381       *-*-aout)
2382         unsupported_languages="$unsupported_languages fortran"
2383         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2384       *-*-elf)
2385         noconfigdirs="$noconfigdirs target-boehm-gc";;
2386       *-*-linux*)
2387         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2388       *)
2389         unsupported_languages="$unsupported_languages fortran"
2390         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2391     esac
2392     libgloss_dir=cris
2393     ;;
2394   crx-*-*)
2395     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2396     ;;
2397   d10v-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   d30v-*-*)
2401     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2402     ;;
2403   ep9312-*-elf | ep9312-*-coff)
2404     libgloss_dir=arm
2405     ;;
2406   fr30-*-elf*)
2407     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2408     ;;
2409   frv-*-*)
2410     noconfigdirs="$noconfigdirs ${libgcj}"
2411     ;;
2412   h8300*-*-*)
2413     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2414     ;;
2415   h8500-*-*)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2419     ;;
2420   hppa*64*-*-linux* | parisc*64*-*-linux*)
2421     # In this case, it's because the hppa64-linux target is for
2422     # the kernel only at this point and has no libc, and thus no
2423     # headers, crt*.o, etc., all of which are needed by these.
2424     noconfigdirs="$noconfigdirs target-zlib"
2425     ;;
2426   parisc*-*-linux* | hppa*-*-linux*)
2427     ;;
2428   hppa*-*-*elf* | \
2429   hppa*-*-lites* | \
2430   hppa*-*-openbsd* | \
2431   hppa*64*-*-*)
2432     noconfigdirs="$noconfigdirs ${libgcj}"
2433     ;;
2434   hppa*-hp-hpux11*)
2435     noconfigdirs="$noconfigdirs ld shellutils"
2436     ;;
2437   hppa*-*-pro*)
2438     libgloss_dir=pa
2439     ;;
2440   hppa*-*-*)
2441     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2442     # build on HP-UX 10.20.
2443     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2444     ;;
2445   i960-*-*)
2446     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2447     ;;
2448   ia64*-*-elf*)
2449     # No gdb support yet.
2450     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2451     ;;
2452   ia64*-**-hpux*)
2453     # No gdb or ld support yet.
2454     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2455     ;;
2456   ia64*-*-*vms*)
2457     # No gdb or ld support yet.
2458     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2459     ;;
2460   i370-*-opened*)
2461     ;;
2462   i[3456789]86-*-coff | i[3456789]86-*-elf)
2463     noconfigdirs="$noconfigdirs ${libgcj}"
2464     libgloss_dir=i386
2465     ;;
2466   i[3456789]86-*-linux*)
2467     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2468     # not build java stuff by default.
2469     case "${target}" in
2470       *-*-*libc1*)
2471         noconfigdirs="$noconfigdirs ${libgcj}";;
2472     esac
2473
2474     # This section makes it possible to build newlib natively on linux.
2475     # If we are using a cross compiler then don't configure newlib.
2476     if test x${is_cross_compiler} != xno ; then
2477       noconfigdirs="$noconfigdirs target-newlib"
2478     fi
2479     noconfigdirs="$noconfigdirs target-libgloss"
2480     # If we are not using a cross compiler, do configure newlib.
2481     # Note however, that newlib will only be configured in this situation
2482     # if the --with-newlib option has been given, because otherwise
2483     # 'target-newlib' will appear in skipdirs.
2484     ;;
2485   i[3456789]86-*-mingw32*)
2486     target_configdirs="$target_configdirs target-winsup"
2487     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2488     ;;
2489   x86_64-*-mingw*)
2490     target_configdirs="$target_configdirs target-winsup"
2491     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2492     ;;
2493   *-*-cygwin*)
2494     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2495     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2496     # always build newlib if winsup directory is present.
2497     if test -d "$srcdir/winsup/cygwin"; then
2498       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2499     elif test -d "$srcdir/newlib"; then
2500       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2501     fi
2502     ;;
2503   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2504   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2505     ;;
2506   i[3456789]86-*-pe)
2507     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2508     ;;
2509   i[3456789]86-*-sco3.2v5*)
2510     # The linker does not yet know about weak symbols in COFF,
2511     # and is not configured to handle mixed ELF and COFF.
2512     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2513     ;;
2514   i[3456789]86-*-sco*)
2515     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2516     ;;
2517   i[3456789]86-*-solaris2*)
2518     noconfigdirs="$noconfigdirs target-libgloss"
2519     ;;
2520   i[3456789]86-*-sysv4*)
2521     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2522     ;;
2523   i[3456789]86-*-beos*)
2524     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2525     ;;
2526   i[3456789]86-*-rdos*)
2527     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2528     ;;
2529   m32r-*-*)
2530     noconfigdirs="$noconfigdirs ${libgcj}"
2531     ;;
2532   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2533     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2534     libgloss_dir=m68hc11
2535     ;;
2536   m68k-*-elf*)
2537     noconfigdirs="$noconfigdirs ${libgcj}"
2538     ;;
2539   m68k-*-coff*)
2540     noconfigdirs="$noconfigdirs ${libgcj}"
2541     ;;
2542   m68*-*-* | fido-*-*)
2543     libgloss_dir=m68k
2544     ;;
2545   mcore-*-pe*)
2546   # The EPOC C++ environment does not support exceptions or rtti,
2547   # and so building libstdc++-v3 tends not to always work.
2548     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2549     ;;
2550   mmix-*-*)
2551     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2552     unsupported_languages="$unsupported_languages fortran java"
2553     ;;
2554   mn10200-*-*)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     ;;
2557   mn10300-*-*)
2558     noconfigdirs="$noconfigdirs ${libgcj}"
2559     ;;
2560   mt-*-*)
2561     noconfigdirs="$noconfigdirs sim"
2562     ;;
2563   powerpc-*-aix*)
2564     # copied from rs6000-*-* entry
2565     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2566     ;;
2567   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2568     target_configdirs="$target_configdirs target-winsup"
2569     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2570     # always build newlib.
2571     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2572     ;;
2573     # This is temporary until we can link against shared libraries
2574   powerpcle-*-solaris*)
2575     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2576     libgloss_dir=rs6000
2577     ;;
2578   powerpc-*-beos*)
2579     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2580     ;;
2581   powerpc-*-eabi)
2582     noconfigdirs="$noconfigdirs ${libgcj}"
2583     libgloss_dir=rs6000
2584     ;;
2585   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2586     libgloss_dir=rs6000
2587     ;;
2588   rs6000-*-lynxos*)
2589     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2590     ;;
2591   rs6000-*-aix*)
2592     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2593     ;;
2594   rs6000-*-*)
2595     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2596     ;;
2597   m68k-apollo-*)
2598     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2599     ;;
2600   mips*-sde-elf*)
2601     skipdirs="$skipdirs target-libiberty"
2602     noconfigdirs="$noconfigdirs ${libgcj}"
2603     if test x$with_newlib = xyes; then
2604       noconfigdirs="$noconfigdirs gprof"
2605     fi
2606     libgloss_dir=mips
2607     ;;
2608   mips*-*-irix5*)
2609     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2610     ;;
2611   mips*-*-irix6*)
2612     # Linking libjava exceeds command-line length limits on at least
2613     # IRIX 6.2, but not on IRIX 6.5.
2614     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2615     # <oldham@codesourcery.com>
2616     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2617     ;;
2618   mips*-*-bsd*)
2619     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2620     ;;
2621   mips*-*-linux*)
2622     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2623     ;;
2624   mips*-*-*)
2625     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2626     libgloss_dir=mips
2627     ;;
2628   romp-*-*)
2629     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2630     ;;
2631   sh-*-* | sh64-*-*)
2632     case "${host}" in
2633       i[3456789]86-*-vsta) ;; # don't add gprof back in
2634       i[3456789]86-*-go32*) ;; # don't add gprof back in
2635       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2636       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2637     esac
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   sparclet-*-aout* | sparc86x-*-*)
2641     libgloss_dir=sparc
2642     ;;
2643   sparc-*-elf*)
2644     noconfigdirs="$noconfigdirs ${libgcj}"
2645     ;;
2646   sparc64-*-elf*)
2647     noconfigdirs="$noconfigdirs ${libgcj}"
2648     libgloss_dir=sparc
2649     ;;
2650   sparclite-*-*)
2651     noconfigdirs="$noconfigdirs ${libgcj}"
2652     libgloss_dir=sparc
2653     ;;
2654   sparc-*-sunos4*)
2655     noconfigdirs="$noconfigdirs ${libgcj}"
2656     if test x${is_cross_compiler} != xno ; then
2657            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2658     else
2659            use_gnu_ld=no
2660     fi
2661     ;;
2662   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2663     noconfigdirs="$noconfigdirs ${libgcj}"
2664     ;;
2665   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2666     ;;
2667   v810-*-*)
2668     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2669     ;;
2670   v850-*-*)
2671     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2672     ;;
2673   v850e-*-*)
2674     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2675     ;;
2676   v850ea-*-*)
2677     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2678     ;;
2679   vax-*-vms)
2680     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2681     ;;
2682   vax-*-*)
2683     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2684     ;;
2685   xtensa*-*-*)
2686     noconfigdirs="$noconfigdirs ${libgcj}"
2687     ;;
2688   ip2k-*-*)
2689     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2690     ;;
2691   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2692     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2693     ;;
2694   *-*-lynxos*)
2695     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2696     ;;
2697   *-*-*)
2698     noconfigdirs="$noconfigdirs ${libgcj}"
2699     ;;
2700 esac
2701
2702 # If we aren't building newlib, then don't build libgloss, since libgloss
2703 # depends upon some newlib header files.
2704 case "${noconfigdirs}" in
2705   *target-libgloss*) ;;
2706   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2707 esac
2708
2709 # Work in distributions that contain no compiler tools, like Autoconf.
2710 tentative_cc=""
2711 host_makefile_frag=/dev/null
2712 if test -d ${srcdir}/config ; then
2713 case "${host}" in
2714   m68k-hp-hpux*)
2715     # Avoid "too much defining" errors from HPUX compiler.
2716     tentative_cc="cc -Wp,-H256000"
2717     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2718     # If it's HP/UX ar, this should be harmless.
2719     RANLIB="ar ts"
2720     ;;
2721   m68k-apollo-sysv*)
2722     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2723     ;;
2724   m68k-apollo-bsd*)
2725     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2726     # chokes on bfd, the compiler won't let you assign integers to enums, and
2727     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2728     # the apollo compiler" (the preferred version of GCC could be called cc,
2729     # or whatever), but I'm not sure leaving CC as cc is any better...
2730     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2731     # Used to have BISON=yacc.
2732     tentative_cc=gcc
2733     ;;
2734   m88k-dg-dgux*)
2735     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2736     ;;
2737   m88k-harris-cxux*)
2738     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2739     tentative_cc="cc -Xa"
2740     host_makefile_frag="config/mh-cxux"
2741     ;;
2742   m88k-motorola-sysv*)
2743     ;;
2744   mips*-dec-ultrix*)
2745     tentative_cc="cc -Wf,-XNg1000"
2746     host_makefile_frag="config/mh-decstation"
2747     ;;
2748   mips*-nec-sysv4*)
2749     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2750     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2751     host_makefile_frag="config/mh-necv4"
2752     ;;
2753   mips*-sgi-irix4*)
2754     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2755     # environment.  Also bump switch table size so that cp-parse will
2756     # compile.  Bump string length limit so linker builds.
2757     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2758     ;;
2759   mips*-*-sysv4*)
2760     host_makefile_frag="config/mh-sysv4"
2761     ;;
2762   mips*-*-sysv*)
2763     # This is for a MIPS running RISC/os 4.52C.
2764
2765     # This is needed for GDB, but needs to be in the top-level make because
2766     # if a library is compiled with the bsd headers and gets linked with the
2767     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2768     # a different size).
2769     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2770     # known except to select the sysv environment.  Could we use /proc instead?
2771     # These "sysv environments" and "bsd environments" often end up being a pain.
2772     #
2773     # This is not part of CFLAGS because perhaps not all C compilers have this
2774     # option.
2775     tentative_cc="cc -systype sysv"
2776     ;;
2777   i370-ibm-opened*)
2778     tentative_cc="c89"
2779     ;;
2780   i[3456789]86-*-sysv5*)
2781     host_makefile_frag="config/mh-sysv5"
2782     ;;
2783   i[3456789]86-*-dgux*)
2784     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2785     host_makefile_frag="config/mh-dgux386"
2786     ;;
2787   i[3456789]86-ncr-sysv4.3*)
2788     # The MetaWare compiler will generate a copyright message unless you
2789     # turn it off by adding the -Hnocopyr flag.
2790     tentative_cc="cc -Hnocopyr"
2791     ;;
2792   i[3456789]86-ncr-sysv4*)
2793     # for an NCR 3000 (i486/SVR4) system.
2794     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2795     # This compiler not only emits obnoxious copyright messages every time
2796     # you run it, but it chokes and dies on a whole bunch of GNU source
2797     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2798     tentative_cc="/usr/ccs/ATT/cc"
2799     host_makefile_frag="config/mh-ncr3000"
2800     ;;
2801   i[3456789]86-*-sco3.2v5*)
2802     ;;
2803   i[3456789]86-*-sco*)
2804     # The native C compiler botches some simple uses of const.  Unfortunately,
2805     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2806     tentative_cc="cc -Dconst="
2807     host_makefile_frag="config/mh-sco"
2808     ;;
2809   i[3456789]86-*-udk*)
2810     host_makefile_frag="config/mh-sysv5"
2811     ;;
2812   i[3456789]86-*-solaris2*)
2813     host_makefile_frag="config/mh-sysv4"
2814     ;;
2815   i[3456789]86-*-msdosdjgpp*)
2816     host_makefile_frag="config/mh-djgpp"
2817     ;;
2818   *-cygwin*)
2819
2820 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2821 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2822 echo a >cygwin-cat-check
2823 if test `cat cygwin-cat-check` == a ; then
2824   rm cygwin-cat-check
2825   echo "$as_me:$LINENO: result: yes" >&5
2826 echo "${ECHO_T}yes" >&6
2827 else
2828   rm cygwin-cat-check
2829   echo "$as_me:$LINENO: result: no" >&5
2830 echo "${ECHO_T}no" >&6
2831   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2832   Please either mount the build directory in binary mode or run the following
2833   commands before running any configure script:
2834 set -o igncr
2835 export SHELLOPTS
2836   " >&5
2837 echo "$as_me: error: The cat command does not ignore carriage return characters.
2838   Please either mount the build directory in binary mode or run the following
2839   commands before running any configure script:
2840 set -o igncr
2841 export SHELLOPTS
2842   " >&2;}
2843    { (exit 1); exit 1; }; }
2844 fi
2845
2846     host_makefile_frag="config/mh-cygwin"
2847     ;;
2848   *-mingw*)
2849     host_makefile_frag="config/mh-mingw"
2850     ;;
2851   *-interix*)
2852     host_makefile_frag="config/mh-interix"
2853     ;;
2854   vax-*-ultrix2*)
2855     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2856     tentative_cc=gcc
2857     ;;
2858   *-*-solaris2*)
2859     host_makefile_frag="config/mh-solaris"
2860     ;;
2861   m68k-sun-sunos*)
2862     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2863     # without overflowing the jump tables (-J says to use a 32 bit table)
2864     tentative_cc="cc -J"
2865     ;;
2866   hppa*-hp-hpux10*)
2867     tentative_cc="cc -Wp,-H256000"
2868     host_makefile_frag="config/mh-pa-hpux10"
2869     ;;
2870   hppa*-hp-hpux* | hppa*-*-hiux*)
2871     tentative_cc="cc -Wp,-H256000"
2872     host_makefile_frag="config/mh-pa"
2873     ;;
2874   hppa*-*)
2875     host_makefile_frag="config/mh-pa"
2876     ;;
2877   *-hp-hpux* | *-*-hiux*)
2878     tentative_cc="cc -Wp,-H256000"
2879     ;;
2880   rs6000-*-lynxos*)
2881     # /bin/cc is less than useful for our purposes.  Always use GCC
2882     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2883     host_makefile_frag="config/mh-lynxrs6k"
2884     ;;
2885   powerpc-*-darwin*)
2886     host_makefile_frag="config/mh-ppc-darwin"
2887     ;;
2888   powerpc-*-aix*)
2889     host_makefile_frag="config/mh-ppc-aix"
2890     ;;
2891   rs6000-*-aix*)
2892     host_makefile_frag="config/mh-ppc-aix"
2893     ;;
2894   *-*-lynxos*)
2895     # /bin/cc is less than useful for our purposes.  Always use GCC
2896     tentative_cc="/bin/gcc"
2897     ;;
2898   *-*-sysv4*)
2899     host_makefile_frag="config/mh-sysv4"
2900     ;;
2901   # This is placed last to prevent interfering with the cases above.
2902   i[3456789]86-*-*)
2903     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2904     host_makefile_frag="config/mh-x86omitfp"
2905     ;;
2906 esac
2907 fi
2908
2909 # If we aren't going to be using gcc, see if we can extract a definition
2910 # of CC from the fragment.
2911 # Actually, use the 'pre-extracted' version above.
2912 if test -z "${CC}" && test "${build}" = "${host}" ; then
2913   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2914   found=
2915   for dir in $PATH; do
2916     test -z "$dir" && dir=.
2917     if test -f $dir/gcc; then
2918       found=yes
2919       break
2920     fi
2921   done
2922   IFS="$save_ifs"
2923   if test -z "${found}" && test -n "${tentative_cc}" ; then
2924     CC=$tentative_cc
2925   fi
2926 fi
2927
2928 if test "${build}" != "${host}" ; then
2929   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2930   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2931   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2932   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2933   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2934   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2935   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2936   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2937   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2938   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2939   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2940   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2941 else
2942   AR_FOR_BUILD="\$(AR)"
2943   AS_FOR_BUILD="\$(AS)"
2944   CC_FOR_BUILD="\$(CC)"
2945   CXX_FOR_BUILD="\$(CXX)"
2946   GCJ_FOR_BUILD="\$(GCJ)"
2947   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2948   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2949   LD_FOR_BUILD="\$(LD)"
2950   NM_FOR_BUILD="\$(NM)"
2951   RANLIB_FOR_BUILD="\$(RANLIB)"
2952   WINDRES_FOR_BUILD="\$(WINDRES)"
2953   WINDMC_FOR_BUILD="\$(WINDMC)"
2954 fi
2955
2956 ac_ext=c
2957 ac_cpp='$CPP $CPPFLAGS'
2958 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2959 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2960 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2961 if test -n "$ac_tool_prefix"; then
2962   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2963 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2964 echo "$as_me:$LINENO: checking for $ac_word" >&5
2965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2966 if test "${ac_cv_prog_CC+set}" = set; then
2967   echo $ECHO_N "(cached) $ECHO_C" >&6
2968 else
2969   if test -n "$CC"; then
2970   ac_cv_prog_CC="$CC" # Let the user override the test.
2971 else
2972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2973 for as_dir in $PATH
2974 do
2975   IFS=$as_save_IFS
2976   test -z "$as_dir" && as_dir=.
2977   for ac_exec_ext in '' $ac_executable_extensions; do
2978   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2979     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2981     break 2
2982   fi
2983 done
2984 done
2985
2986 fi
2987 fi
2988 CC=$ac_cv_prog_CC
2989 if test -n "$CC"; then
2990   echo "$as_me:$LINENO: result: $CC" >&5
2991 echo "${ECHO_T}$CC" >&6
2992 else
2993   echo "$as_me:$LINENO: result: no" >&5
2994 echo "${ECHO_T}no" >&6
2995 fi
2996
2997 fi
2998 if test -z "$ac_cv_prog_CC"; then
2999   ac_ct_CC=$CC
3000   # Extract the first word of "gcc", so it can be a program name with args.
3001 set dummy gcc; ac_word=$2
3002 echo "$as_me:$LINENO: checking for $ac_word" >&5
3003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3004 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3005   echo $ECHO_N "(cached) $ECHO_C" >&6
3006 else
3007   if test -n "$ac_ct_CC"; then
3008   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3009 else
3010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3011 for as_dir in $PATH
3012 do
3013   IFS=$as_save_IFS
3014   test -z "$as_dir" && as_dir=.
3015   for ac_exec_ext in '' $ac_executable_extensions; do
3016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3017     ac_cv_prog_ac_ct_CC="gcc"
3018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3019     break 2
3020   fi
3021 done
3022 done
3023
3024 fi
3025 fi
3026 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3027 if test -n "$ac_ct_CC"; then
3028   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3029 echo "${ECHO_T}$ac_ct_CC" >&6
3030 else
3031   echo "$as_me:$LINENO: result: no" >&5
3032 echo "${ECHO_T}no" >&6
3033 fi
3034
3035   CC=$ac_ct_CC
3036 else
3037   CC="$ac_cv_prog_CC"
3038 fi
3039
3040 if test -z "$CC"; then
3041   if test -n "$ac_tool_prefix"; then
3042   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3043 set dummy ${ac_tool_prefix}cc; ac_word=$2
3044 echo "$as_me:$LINENO: checking for $ac_word" >&5
3045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3046 if test "${ac_cv_prog_CC+set}" = set; then
3047   echo $ECHO_N "(cached) $ECHO_C" >&6
3048 else
3049   if test -n "$CC"; then
3050   ac_cv_prog_CC="$CC" # Let the user override the test.
3051 else
3052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3053 for as_dir in $PATH
3054 do
3055   IFS=$as_save_IFS
3056   test -z "$as_dir" && as_dir=.
3057   for ac_exec_ext in '' $ac_executable_extensions; do
3058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3059     ac_cv_prog_CC="${ac_tool_prefix}cc"
3060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3061     break 2
3062   fi
3063 done
3064 done
3065
3066 fi
3067 fi
3068 CC=$ac_cv_prog_CC
3069 if test -n "$CC"; then
3070   echo "$as_me:$LINENO: result: $CC" >&5
3071 echo "${ECHO_T}$CC" >&6
3072 else
3073   echo "$as_me:$LINENO: result: no" >&5
3074 echo "${ECHO_T}no" >&6
3075 fi
3076
3077 fi
3078 if test -z "$ac_cv_prog_CC"; then
3079   ac_ct_CC=$CC
3080   # Extract the first word of "cc", so it can be a program name with args.
3081 set dummy cc; ac_word=$2
3082 echo "$as_me:$LINENO: checking for $ac_word" >&5
3083 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3084 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3085   echo $ECHO_N "(cached) $ECHO_C" >&6
3086 else
3087   if test -n "$ac_ct_CC"; then
3088   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3089 else
3090 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3091 for as_dir in $PATH
3092 do
3093   IFS=$as_save_IFS
3094   test -z "$as_dir" && as_dir=.
3095   for ac_exec_ext in '' $ac_executable_extensions; do
3096   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3097     ac_cv_prog_ac_ct_CC="cc"
3098     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3099     break 2
3100   fi
3101 done
3102 done
3103
3104 fi
3105 fi
3106 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3107 if test -n "$ac_ct_CC"; then
3108   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3109 echo "${ECHO_T}$ac_ct_CC" >&6
3110 else
3111   echo "$as_me:$LINENO: result: no" >&5
3112 echo "${ECHO_T}no" >&6
3113 fi
3114
3115   CC=$ac_ct_CC
3116 else
3117   CC="$ac_cv_prog_CC"
3118 fi
3119
3120 fi
3121 if test -z "$CC"; then
3122   # Extract the first word of "cc", so it can be a program name with args.
3123 set dummy cc; ac_word=$2
3124 echo "$as_me:$LINENO: checking for $ac_word" >&5
3125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3126 if test "${ac_cv_prog_CC+set}" = set; then
3127   echo $ECHO_N "(cached) $ECHO_C" >&6
3128 else
3129   if test -n "$CC"; then
3130   ac_cv_prog_CC="$CC" # Let the user override the test.
3131 else
3132   ac_prog_rejected=no
3133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3134 for as_dir in $PATH
3135 do
3136   IFS=$as_save_IFS
3137   test -z "$as_dir" && as_dir=.
3138   for ac_exec_ext in '' $ac_executable_extensions; do
3139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3140     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3141        ac_prog_rejected=yes
3142        continue
3143      fi
3144     ac_cv_prog_CC="cc"
3145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3146     break 2
3147   fi
3148 done
3149 done
3150
3151 if test $ac_prog_rejected = yes; then
3152   # We found a bogon in the path, so make sure we never use it.
3153   set dummy $ac_cv_prog_CC
3154   shift
3155   if test $# != 0; then
3156     # We chose a different compiler from the bogus one.
3157     # However, it has the same basename, so the bogon will be chosen
3158     # first if we set CC to just the basename; use the full file name.
3159     shift
3160     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3161   fi
3162 fi
3163 fi
3164 fi
3165 CC=$ac_cv_prog_CC
3166 if test -n "$CC"; then
3167   echo "$as_me:$LINENO: result: $CC" >&5
3168 echo "${ECHO_T}$CC" >&6
3169 else
3170   echo "$as_me:$LINENO: result: no" >&5
3171 echo "${ECHO_T}no" >&6
3172 fi
3173
3174 fi
3175 if test -z "$CC"; then
3176   if test -n "$ac_tool_prefix"; then
3177   for ac_prog in cl
3178   do
3179     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3180 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3181 echo "$as_me:$LINENO: checking for $ac_word" >&5
3182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3183 if test "${ac_cv_prog_CC+set}" = set; then
3184   echo $ECHO_N "(cached) $ECHO_C" >&6
3185 else
3186   if test -n "$CC"; then
3187   ac_cv_prog_CC="$CC" # Let the user override the test.
3188 else
3189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3190 for as_dir in $PATH
3191 do
3192   IFS=$as_save_IFS
3193   test -z "$as_dir" && as_dir=.
3194   for ac_exec_ext in '' $ac_executable_extensions; do
3195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3196     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3198     break 2
3199   fi
3200 done
3201 done
3202
3203 fi
3204 fi
3205 CC=$ac_cv_prog_CC
3206 if test -n "$CC"; then
3207   echo "$as_me:$LINENO: result: $CC" >&5
3208 echo "${ECHO_T}$CC" >&6
3209 else
3210   echo "$as_me:$LINENO: result: no" >&5
3211 echo "${ECHO_T}no" >&6
3212 fi
3213
3214     test -n "$CC" && break
3215   done
3216 fi
3217 if test -z "$CC"; then
3218   ac_ct_CC=$CC
3219   for ac_prog in cl
3220 do
3221   # Extract the first word of "$ac_prog", so it can be a program name with args.
3222 set dummy $ac_prog; ac_word=$2
3223 echo "$as_me:$LINENO: checking for $ac_word" >&5
3224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3225 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3226   echo $ECHO_N "(cached) $ECHO_C" >&6
3227 else
3228   if test -n "$ac_ct_CC"; then
3229   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3230 else
3231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3232 for as_dir in $PATH
3233 do
3234   IFS=$as_save_IFS
3235   test -z "$as_dir" && as_dir=.
3236   for ac_exec_ext in '' $ac_executable_extensions; do
3237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3238     ac_cv_prog_ac_ct_CC="$ac_prog"
3239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3240     break 2
3241   fi
3242 done
3243 done
3244
3245 fi
3246 fi
3247 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3248 if test -n "$ac_ct_CC"; then
3249   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3250 echo "${ECHO_T}$ac_ct_CC" >&6
3251 else
3252   echo "$as_me:$LINENO: result: no" >&5
3253 echo "${ECHO_T}no" >&6
3254 fi
3255
3256   test -n "$ac_ct_CC" && break
3257 done
3258
3259   CC=$ac_ct_CC
3260 fi
3261
3262 fi
3263
3264
3265 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3266 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3267 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3268 See \`config.log' for more details." >&5
3269 echo "$as_me: error: no acceptable C compiler found in \$PATH
3270 See \`config.log' for more details." >&2;}
3271    { (exit 1); exit 1; }; }; }
3272
3273 # Provide some information about the compiler.
3274 echo "$as_me:$LINENO:" \
3275      "checking for C compiler version" >&5
3276 ac_compiler=`set X $ac_compile; echo $2`
3277 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3278   (eval $ac_compiler --version </dev/null >&5) 2>&5
3279   ac_status=$?
3280   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3281   (exit $ac_status); }
3282 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3283   (eval $ac_compiler -v </dev/null >&5) 2>&5
3284   ac_status=$?
3285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3286   (exit $ac_status); }
3287 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3288   (eval $ac_compiler -V </dev/null >&5) 2>&5
3289   ac_status=$?
3290   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3291   (exit $ac_status); }
3292
3293 cat >conftest.$ac_ext <<_ACEOF
3294 /* confdefs.h.  */
3295 _ACEOF
3296 cat confdefs.h >>conftest.$ac_ext
3297 cat >>conftest.$ac_ext <<_ACEOF
3298 /* end confdefs.h.  */
3299
3300 int
3301 main ()
3302 {
3303
3304   ;
3305   return 0;
3306 }
3307 _ACEOF
3308 ac_clean_files_save=$ac_clean_files
3309 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3310 # Try to create an executable without -o first, disregard a.out.
3311 # It will help us diagnose broken compilers, and finding out an intuition
3312 # of exeext.
3313 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3314 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3315 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3316 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3317   (eval $ac_link_default) 2>&5
3318   ac_status=$?
3319   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3320   (exit $ac_status); }; then
3321   # Find the output, starting from the most likely.  This scheme is
3322 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3323 # resort.
3324
3325 # Be careful to initialize this variable, since it used to be cached.
3326 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3327 ac_cv_exeext=
3328 # b.out is created by i960 compilers.
3329 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3330 do
3331   test -f "$ac_file" || continue
3332   case $ac_file in
3333     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3334         ;;
3335     conftest.$ac_ext )
3336         # This is the source file.
3337         ;;
3338     [ab].out )
3339         # We found the default executable, but exeext='' is most
3340         # certainly right.
3341         break;;
3342     *.* )
3343         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3344         # FIXME: I believe we export ac_cv_exeext for Libtool,
3345         # but it would be cool to find out if it's true.  Does anybody
3346         # maintain Libtool? --akim.
3347         export ac_cv_exeext
3348         break;;
3349     * )
3350         break;;
3351   esac
3352 done
3353 else
3354   echo "$as_me: failed program was:" >&5
3355 sed 's/^/| /' conftest.$ac_ext >&5
3356
3357 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3358 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3359 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3360 See \`config.log' for more details." >&5
3361 echo "$as_me: error: C compiler cannot create executables
3362 See \`config.log' for more details." >&2;}
3363    { (exit 77); exit 77; }; }; }
3364 fi
3365
3366 ac_exeext=$ac_cv_exeext
3367 echo "$as_me:$LINENO: result: $ac_file" >&5
3368 echo "${ECHO_T}$ac_file" >&6
3369
3370 # Check the compiler produces executables we can run.  If not, either
3371 # the compiler is broken, or we cross compile.
3372 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3373 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3374 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3375 # If not cross compiling, check that we can run a simple program.
3376 if test "$cross_compiling" != yes; then
3377   if { ac_try='./$ac_file'
3378   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3379   (eval $ac_try) 2>&5
3380   ac_status=$?
3381   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3382   (exit $ac_status); }; }; then
3383     cross_compiling=no
3384   else
3385     if test "$cross_compiling" = maybe; then
3386         cross_compiling=yes
3387     else
3388         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3389 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3390 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3391 If you meant to cross compile, use \`--host'.
3392 See \`config.log' for more details." >&5
3393 echo "$as_me: error: cannot run C compiled programs.
3394 If you meant to cross compile, use \`--host'.
3395 See \`config.log' for more details." >&2;}
3396    { (exit 1); exit 1; }; }; }
3397     fi
3398   fi
3399 fi
3400 echo "$as_me:$LINENO: result: yes" >&5
3401 echo "${ECHO_T}yes" >&6
3402
3403 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3404 ac_clean_files=$ac_clean_files_save
3405 # Check the compiler produces executables we can run.  If not, either
3406 # the compiler is broken, or we cross compile.
3407 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3408 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3409 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3410 echo "${ECHO_T}$cross_compiling" >&6
3411
3412 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3413 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3414 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3415   (eval $ac_link) 2>&5
3416   ac_status=$?
3417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3418   (exit $ac_status); }; then
3419   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3420 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3421 # work properly (i.e., refer to `conftest.exe'), while it won't with
3422 # `rm'.
3423 for ac_file in conftest.exe conftest conftest.*; do
3424   test -f "$ac_file" || continue
3425   case $ac_file in
3426     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3427     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3428           export ac_cv_exeext
3429           break;;
3430     * ) break;;
3431   esac
3432 done
3433 else
3434   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3435 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3436 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3437 See \`config.log' for more details." >&5
3438 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3439 See \`config.log' for more details." >&2;}
3440    { (exit 1); exit 1; }; }; }
3441 fi
3442
3443 rm -f conftest$ac_cv_exeext
3444 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3445 echo "${ECHO_T}$ac_cv_exeext" >&6
3446
3447 rm -f conftest.$ac_ext
3448 EXEEXT=$ac_cv_exeext
3449 ac_exeext=$EXEEXT
3450 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3451 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3452 if test "${ac_cv_objext+set}" = set; then
3453   echo $ECHO_N "(cached) $ECHO_C" >&6
3454 else
3455   cat >conftest.$ac_ext <<_ACEOF
3456 /* confdefs.h.  */
3457 _ACEOF
3458 cat confdefs.h >>conftest.$ac_ext
3459 cat >>conftest.$ac_ext <<_ACEOF
3460 /* end confdefs.h.  */
3461
3462 int
3463 main ()
3464 {
3465
3466   ;
3467   return 0;
3468 }
3469 _ACEOF
3470 rm -f conftest.o conftest.obj
3471 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3472   (eval $ac_compile) 2>&5
3473   ac_status=$?
3474   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3475   (exit $ac_status); }; then
3476   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3477   case $ac_file in
3478     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3479     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3480        break;;
3481   esac
3482 done
3483 else
3484   echo "$as_me: failed program was:" >&5
3485 sed 's/^/| /' conftest.$ac_ext >&5
3486
3487 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3488 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3489 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3490 See \`config.log' for more details." >&5
3491 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3492 See \`config.log' for more details." >&2;}
3493    { (exit 1); exit 1; }; }; }
3494 fi
3495
3496 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3497 fi
3498 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3499 echo "${ECHO_T}$ac_cv_objext" >&6
3500 OBJEXT=$ac_cv_objext
3501 ac_objext=$OBJEXT
3502 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3503 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3504 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3505   echo $ECHO_N "(cached) $ECHO_C" >&6
3506 else
3507   cat >conftest.$ac_ext <<_ACEOF
3508 /* confdefs.h.  */
3509 _ACEOF
3510 cat confdefs.h >>conftest.$ac_ext
3511 cat >>conftest.$ac_ext <<_ACEOF
3512 /* end confdefs.h.  */
3513
3514 int
3515 main ()
3516 {
3517 #ifndef __GNUC__
3518        choke me
3519 #endif
3520
3521   ;
3522   return 0;
3523 }
3524 _ACEOF
3525 rm -f conftest.$ac_objext
3526 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3527   (eval $ac_compile) 2>conftest.er1
3528   ac_status=$?
3529   grep -v '^ *+' conftest.er1 >conftest.err
3530   rm -f conftest.er1
3531   cat conftest.err >&5
3532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3533   (exit $ac_status); } &&
3534          { ac_try='test -z "$ac_c_werror_flag"
3535                          || test ! -s conftest.err'
3536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3537   (eval $ac_try) 2>&5
3538   ac_status=$?
3539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3540   (exit $ac_status); }; } &&
3541          { ac_try='test -s conftest.$ac_objext'
3542   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3543   (eval $ac_try) 2>&5
3544   ac_status=$?
3545   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3546   (exit $ac_status); }; }; then
3547   ac_compiler_gnu=yes
3548 else
3549   echo "$as_me: failed program was:" >&5
3550 sed 's/^/| /' conftest.$ac_ext >&5
3551
3552 ac_compiler_gnu=no
3553 fi
3554 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3555 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3556
3557 fi
3558 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3559 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3560 GCC=`test $ac_compiler_gnu = yes && echo yes`
3561 ac_test_CFLAGS=${CFLAGS+set}
3562 ac_save_CFLAGS=$CFLAGS
3563 CFLAGS="-g"
3564 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3565 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3566 if test "${ac_cv_prog_cc_g+set}" = set; then
3567   echo $ECHO_N "(cached) $ECHO_C" >&6
3568 else
3569   cat >conftest.$ac_ext <<_ACEOF
3570 /* confdefs.h.  */
3571 _ACEOF
3572 cat confdefs.h >>conftest.$ac_ext
3573 cat >>conftest.$ac_ext <<_ACEOF
3574 /* end confdefs.h.  */
3575
3576 int
3577 main ()
3578 {
3579
3580   ;
3581   return 0;
3582 }
3583 _ACEOF
3584 rm -f conftest.$ac_objext
3585 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3586   (eval $ac_compile) 2>conftest.er1
3587   ac_status=$?
3588   grep -v '^ *+' conftest.er1 >conftest.err
3589   rm -f conftest.er1
3590   cat conftest.err >&5
3591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3592   (exit $ac_status); } &&
3593          { ac_try='test -z "$ac_c_werror_flag"
3594                          || test ! -s conftest.err'
3595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3596   (eval $ac_try) 2>&5
3597   ac_status=$?
3598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3599   (exit $ac_status); }; } &&
3600          { ac_try='test -s conftest.$ac_objext'
3601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3602   (eval $ac_try) 2>&5
3603   ac_status=$?
3604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3605   (exit $ac_status); }; }; then
3606   ac_cv_prog_cc_g=yes
3607 else
3608   echo "$as_me: failed program was:" >&5
3609 sed 's/^/| /' conftest.$ac_ext >&5
3610
3611 ac_cv_prog_cc_g=no
3612 fi
3613 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3614 fi
3615 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3616 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3617 if test "$ac_test_CFLAGS" = set; then
3618   CFLAGS=$ac_save_CFLAGS
3619 elif test $ac_cv_prog_cc_g = yes; then
3620   if test "$GCC" = yes; then
3621     CFLAGS="-g -O2"
3622   else
3623     CFLAGS="-g"
3624   fi
3625 else
3626   if test "$GCC" = yes; then
3627     CFLAGS="-O2"
3628   else
3629     CFLAGS=
3630   fi
3631 fi
3632 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3633 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3634 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3635   echo $ECHO_N "(cached) $ECHO_C" >&6
3636 else
3637   ac_cv_prog_cc_stdc=no
3638 ac_save_CC=$CC
3639 cat >conftest.$ac_ext <<_ACEOF
3640 /* confdefs.h.  */
3641 _ACEOF
3642 cat confdefs.h >>conftest.$ac_ext
3643 cat >>conftest.$ac_ext <<_ACEOF
3644 /* end confdefs.h.  */
3645 #include <stdarg.h>
3646 #include <stdio.h>
3647 #include <sys/types.h>
3648 #include <sys/stat.h>
3649 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3650 struct buf { int x; };
3651 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3652 static char *e (p, i)
3653      char **p;
3654      int i;
3655 {
3656   return p[i];
3657 }
3658 static char *f (char * (*g) (char **, int), char **p, ...)
3659 {
3660   char *s;
3661   va_list v;
3662   va_start (v,p);
3663   s = g (p, va_arg (v,int));
3664   va_end (v);
3665   return s;
3666 }
3667
3668 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3669    function prototypes and stuff, but not '\xHH' hex character constants.
3670    These don't provoke an error unfortunately, instead are silently treated
3671    as 'x'.  The following induces an error, until -std1 is added to get
3672    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3673    array size at least.  It's necessary to write '\x00'==0 to get something
3674    that's true only with -std1.  */
3675 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3676
3677 int test (int i, double x);
3678 struct s1 {int (*f) (int a);};
3679 struct s2 {int (*f) (double a);};
3680 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3681 int argc;
3682 char **argv;
3683 int
3684 main ()
3685 {
3686 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3687   ;
3688   return 0;
3689 }
3690 _ACEOF
3691 # Don't try gcc -ansi; that turns off useful extensions and
3692 # breaks some systems' header files.
3693 # AIX                   -qlanglvl=ansi
3694 # Ultrix and OSF/1      -std1
3695 # HP-UX 10.20 and later -Ae
3696 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3697 # SVR4                  -Xc -D__EXTENSIONS__
3698 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3699 do
3700   CC="$ac_save_CC $ac_arg"
3701   rm -f conftest.$ac_objext
3702 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3703   (eval $ac_compile) 2>conftest.er1
3704   ac_status=$?
3705   grep -v '^ *+' conftest.er1 >conftest.err
3706   rm -f conftest.er1
3707   cat conftest.err >&5
3708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3709   (exit $ac_status); } &&
3710          { ac_try='test -z "$ac_c_werror_flag"
3711                          || test ! -s conftest.err'
3712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3713   (eval $ac_try) 2>&5
3714   ac_status=$?
3715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3716   (exit $ac_status); }; } &&
3717          { ac_try='test -s conftest.$ac_objext'
3718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3719   (eval $ac_try) 2>&5
3720   ac_status=$?
3721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3722   (exit $ac_status); }; }; then
3723   ac_cv_prog_cc_stdc=$ac_arg
3724 break
3725 else
3726   echo "$as_me: failed program was:" >&5
3727 sed 's/^/| /' conftest.$ac_ext >&5
3728
3729 fi
3730 rm -f conftest.err conftest.$ac_objext
3731 done
3732 rm -f conftest.$ac_ext conftest.$ac_objext
3733 CC=$ac_save_CC
3734
3735 fi
3736
3737 case "x$ac_cv_prog_cc_stdc" in
3738   x|xno)
3739     echo "$as_me:$LINENO: result: none needed" >&5
3740 echo "${ECHO_T}none needed" >&6 ;;
3741   *)
3742     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3743 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3744     CC="$CC $ac_cv_prog_cc_stdc" ;;
3745 esac
3746
3747 # Some people use a C++ compiler to compile C.  Since we use `exit',
3748 # in C++ we need to declare it.  In case someone uses the same compiler
3749 # for both compiling C and C++ we need to have the C++ compiler decide
3750 # the declaration of exit, since it's the most demanding environment.
3751 cat >conftest.$ac_ext <<_ACEOF
3752 #ifndef __cplusplus
3753   choke me
3754 #endif
3755 _ACEOF
3756 rm -f conftest.$ac_objext
3757 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3758   (eval $ac_compile) 2>conftest.er1
3759   ac_status=$?
3760   grep -v '^ *+' conftest.er1 >conftest.err
3761   rm -f conftest.er1
3762   cat conftest.err >&5
3763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3764   (exit $ac_status); } &&
3765          { ac_try='test -z "$ac_c_werror_flag"
3766                          || test ! -s conftest.err'
3767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3768   (eval $ac_try) 2>&5
3769   ac_status=$?
3770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3771   (exit $ac_status); }; } &&
3772          { ac_try='test -s conftest.$ac_objext'
3773   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3774   (eval $ac_try) 2>&5
3775   ac_status=$?
3776   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3777   (exit $ac_status); }; }; then
3778   for ac_declaration in \
3779    '' \
3780    'extern "C" void std::exit (int) throw (); using std::exit;' \
3781    'extern "C" void std::exit (int); using std::exit;' \
3782    'extern "C" void exit (int) throw ();' \
3783    'extern "C" void exit (int);' \
3784    'void exit (int);'
3785 do
3786   cat >conftest.$ac_ext <<_ACEOF
3787 /* confdefs.h.  */
3788 _ACEOF
3789 cat confdefs.h >>conftest.$ac_ext
3790 cat >>conftest.$ac_ext <<_ACEOF
3791 /* end confdefs.h.  */
3792 $ac_declaration
3793 #include <stdlib.h>
3794 int
3795 main ()
3796 {
3797 exit (42);
3798   ;
3799   return 0;
3800 }
3801 _ACEOF
3802 rm -f conftest.$ac_objext
3803 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3804   (eval $ac_compile) 2>conftest.er1
3805   ac_status=$?
3806   grep -v '^ *+' conftest.er1 >conftest.err
3807   rm -f conftest.er1
3808   cat conftest.err >&5
3809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3810   (exit $ac_status); } &&
3811          { ac_try='test -z "$ac_c_werror_flag"
3812                          || test ! -s conftest.err'
3813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814   (eval $ac_try) 2>&5
3815   ac_status=$?
3816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817   (exit $ac_status); }; } &&
3818          { ac_try='test -s conftest.$ac_objext'
3819   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3820   (eval $ac_try) 2>&5
3821   ac_status=$?
3822   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3823   (exit $ac_status); }; }; then
3824   :
3825 else
3826   echo "$as_me: failed program was:" >&5
3827 sed 's/^/| /' conftest.$ac_ext >&5
3828
3829 continue
3830 fi
3831 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3832   cat >conftest.$ac_ext <<_ACEOF
3833 /* confdefs.h.  */
3834 _ACEOF
3835 cat confdefs.h >>conftest.$ac_ext
3836 cat >>conftest.$ac_ext <<_ACEOF
3837 /* end confdefs.h.  */
3838 $ac_declaration
3839 int
3840 main ()
3841 {
3842 exit (42);
3843   ;
3844   return 0;
3845 }
3846 _ACEOF
3847 rm -f conftest.$ac_objext
3848 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3849   (eval $ac_compile) 2>conftest.er1
3850   ac_status=$?
3851   grep -v '^ *+' conftest.er1 >conftest.err
3852   rm -f conftest.er1
3853   cat conftest.err >&5
3854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3855   (exit $ac_status); } &&
3856          { ac_try='test -z "$ac_c_werror_flag"
3857                          || test ! -s conftest.err'
3858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3859   (eval $ac_try) 2>&5
3860   ac_status=$?
3861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3862   (exit $ac_status); }; } &&
3863          { ac_try='test -s conftest.$ac_objext'
3864   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3865   (eval $ac_try) 2>&5
3866   ac_status=$?
3867   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3868   (exit $ac_status); }; }; then
3869   break
3870 else
3871   echo "$as_me: failed program was:" >&5
3872 sed 's/^/| /' conftest.$ac_ext >&5
3873
3874 fi
3875 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3876 done
3877 rm -f conftest*
3878 if test -n "$ac_declaration"; then
3879   echo '#ifdef __cplusplus' >>confdefs.h
3880   echo $ac_declaration      >>confdefs.h
3881   echo '#endif'             >>confdefs.h
3882 fi
3883
3884 else
3885   echo "$as_me: failed program was:" >&5
3886 sed 's/^/| /' conftest.$ac_ext >&5
3887
3888 fi
3889 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3890 ac_ext=c
3891 ac_cpp='$CPP $CPPFLAGS'
3892 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3893 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3894 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3895
3896 ac_ext=cc
3897 ac_cpp='$CXXCPP $CPPFLAGS'
3898 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3899 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3900 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3901 if test -n "$ac_tool_prefix"; then
3902   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3903   do
3904     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3905 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3906 echo "$as_me:$LINENO: checking for $ac_word" >&5
3907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3908 if test "${ac_cv_prog_CXX+set}" = set; then
3909   echo $ECHO_N "(cached) $ECHO_C" >&6
3910 else
3911   if test -n "$CXX"; then
3912   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3913 else
3914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3915 for as_dir in $PATH
3916 do
3917   IFS=$as_save_IFS
3918   test -z "$as_dir" && as_dir=.
3919   for ac_exec_ext in '' $ac_executable_extensions; do
3920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3921     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3923     break 2
3924   fi
3925 done
3926 done
3927
3928 fi
3929 fi
3930 CXX=$ac_cv_prog_CXX
3931 if test -n "$CXX"; then
3932   echo "$as_me:$LINENO: result: $CXX" >&5
3933 echo "${ECHO_T}$CXX" >&6
3934 else
3935   echo "$as_me:$LINENO: result: no" >&5
3936 echo "${ECHO_T}no" >&6
3937 fi
3938
3939     test -n "$CXX" && break
3940   done
3941 fi
3942 if test -z "$CXX"; then
3943   ac_ct_CXX=$CXX
3944   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3945 do
3946   # Extract the first word of "$ac_prog", so it can be a program name with args.
3947 set dummy $ac_prog; ac_word=$2
3948 echo "$as_me:$LINENO: checking for $ac_word" >&5
3949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3950 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3951   echo $ECHO_N "(cached) $ECHO_C" >&6
3952 else
3953   if test -n "$ac_ct_CXX"; then
3954   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3955 else
3956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3957 for as_dir in $PATH
3958 do
3959   IFS=$as_save_IFS
3960   test -z "$as_dir" && as_dir=.
3961   for ac_exec_ext in '' $ac_executable_extensions; do
3962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3963     ac_cv_prog_ac_ct_CXX="$ac_prog"
3964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3965     break 2
3966   fi
3967 done
3968 done
3969
3970 fi
3971 fi
3972 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3973 if test -n "$ac_ct_CXX"; then
3974   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3975 echo "${ECHO_T}$ac_ct_CXX" >&6
3976 else
3977   echo "$as_me:$LINENO: result: no" >&5
3978 echo "${ECHO_T}no" >&6
3979 fi
3980
3981   test -n "$ac_ct_CXX" && break
3982 done
3983 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3984
3985   CXX=$ac_ct_CXX
3986 fi
3987
3988
3989 # Provide some information about the compiler.
3990 echo "$as_me:$LINENO:" \
3991      "checking for C++ compiler version" >&5
3992 ac_compiler=`set X $ac_compile; echo $2`
3993 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3994   (eval $ac_compiler --version </dev/null >&5) 2>&5
3995   ac_status=$?
3996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997   (exit $ac_status); }
3998 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3999   (eval $ac_compiler -v </dev/null >&5) 2>&5
4000   ac_status=$?
4001   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4002   (exit $ac_status); }
4003 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4004   (eval $ac_compiler -V </dev/null >&5) 2>&5
4005   ac_status=$?
4006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4007   (exit $ac_status); }
4008
4009 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4010 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4011 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4012   echo $ECHO_N "(cached) $ECHO_C" >&6
4013 else
4014   cat >conftest.$ac_ext <<_ACEOF
4015 /* confdefs.h.  */
4016 _ACEOF
4017 cat confdefs.h >>conftest.$ac_ext
4018 cat >>conftest.$ac_ext <<_ACEOF
4019 /* end confdefs.h.  */
4020
4021 int
4022 main ()
4023 {
4024 #ifndef __GNUC__
4025        choke me
4026 #endif
4027
4028   ;
4029   return 0;
4030 }
4031 _ACEOF
4032 rm -f conftest.$ac_objext
4033 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4034   (eval $ac_compile) 2>conftest.er1
4035   ac_status=$?
4036   grep -v '^ *+' conftest.er1 >conftest.err
4037   rm -f conftest.er1
4038   cat conftest.err >&5
4039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4040   (exit $ac_status); } &&
4041          { ac_try='test -z "$ac_cxx_werror_flag"
4042                          || test ! -s conftest.err'
4043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4044   (eval $ac_try) 2>&5
4045   ac_status=$?
4046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4047   (exit $ac_status); }; } &&
4048          { ac_try='test -s conftest.$ac_objext'
4049   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4050   (eval $ac_try) 2>&5
4051   ac_status=$?
4052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4053   (exit $ac_status); }; }; then
4054   ac_compiler_gnu=yes
4055 else
4056   echo "$as_me: failed program was:" >&5
4057 sed 's/^/| /' conftest.$ac_ext >&5
4058
4059 ac_compiler_gnu=no
4060 fi
4061 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4062 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4063
4064 fi
4065 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4066 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4067 GXX=`test $ac_compiler_gnu = yes && echo yes`
4068 ac_test_CXXFLAGS=${CXXFLAGS+set}
4069 ac_save_CXXFLAGS=$CXXFLAGS
4070 CXXFLAGS="-g"
4071 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4072 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4073 if test "${ac_cv_prog_cxx_g+set}" = set; then
4074   echo $ECHO_N "(cached) $ECHO_C" >&6
4075 else
4076   cat >conftest.$ac_ext <<_ACEOF
4077 /* confdefs.h.  */
4078 _ACEOF
4079 cat confdefs.h >>conftest.$ac_ext
4080 cat >>conftest.$ac_ext <<_ACEOF
4081 /* end confdefs.h.  */
4082
4083 int
4084 main ()
4085 {
4086
4087   ;
4088   return 0;
4089 }
4090 _ACEOF
4091 rm -f conftest.$ac_objext
4092 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4093   (eval $ac_compile) 2>conftest.er1
4094   ac_status=$?
4095   grep -v '^ *+' conftest.er1 >conftest.err
4096   rm -f conftest.er1
4097   cat conftest.err >&5
4098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4099   (exit $ac_status); } &&
4100          { ac_try='test -z "$ac_cxx_werror_flag"
4101                          || test ! -s conftest.err'
4102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4103   (eval $ac_try) 2>&5
4104   ac_status=$?
4105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4106   (exit $ac_status); }; } &&
4107          { ac_try='test -s conftest.$ac_objext'
4108   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4109   (eval $ac_try) 2>&5
4110   ac_status=$?
4111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4112   (exit $ac_status); }; }; then
4113   ac_cv_prog_cxx_g=yes
4114 else
4115   echo "$as_me: failed program was:" >&5
4116 sed 's/^/| /' conftest.$ac_ext >&5
4117
4118 ac_cv_prog_cxx_g=no
4119 fi
4120 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4121 fi
4122 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4123 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4124 if test "$ac_test_CXXFLAGS" = set; then
4125   CXXFLAGS=$ac_save_CXXFLAGS
4126 elif test $ac_cv_prog_cxx_g = yes; then
4127   if test "$GXX" = yes; then
4128     CXXFLAGS="-g -O2"
4129   else
4130     CXXFLAGS="-g"
4131   fi
4132 else
4133   if test "$GXX" = yes; then
4134     CXXFLAGS="-O2"
4135   else
4136     CXXFLAGS=
4137   fi
4138 fi
4139 for ac_declaration in \
4140    '' \
4141    'extern "C" void std::exit (int) throw (); using std::exit;' \
4142    'extern "C" void std::exit (int); using std::exit;' \
4143    'extern "C" void exit (int) throw ();' \
4144    'extern "C" void exit (int);' \
4145    'void exit (int);'
4146 do
4147   cat >conftest.$ac_ext <<_ACEOF
4148 /* confdefs.h.  */
4149 _ACEOF
4150 cat confdefs.h >>conftest.$ac_ext
4151 cat >>conftest.$ac_ext <<_ACEOF
4152 /* end confdefs.h.  */
4153 $ac_declaration
4154 #include <stdlib.h>
4155 int
4156 main ()
4157 {
4158 exit (42);
4159   ;
4160   return 0;
4161 }
4162 _ACEOF
4163 rm -f conftest.$ac_objext
4164 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4165   (eval $ac_compile) 2>conftest.er1
4166   ac_status=$?
4167   grep -v '^ *+' conftest.er1 >conftest.err
4168   rm -f conftest.er1
4169   cat conftest.err >&5
4170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4171   (exit $ac_status); } &&
4172          { ac_try='test -z "$ac_cxx_werror_flag"
4173                          || test ! -s conftest.err'
4174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4175   (eval $ac_try) 2>&5
4176   ac_status=$?
4177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4178   (exit $ac_status); }; } &&
4179          { ac_try='test -s conftest.$ac_objext'
4180   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4181   (eval $ac_try) 2>&5
4182   ac_status=$?
4183   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4184   (exit $ac_status); }; }; then
4185   :
4186 else
4187   echo "$as_me: failed program was:" >&5
4188 sed 's/^/| /' conftest.$ac_ext >&5
4189
4190 continue
4191 fi
4192 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4193   cat >conftest.$ac_ext <<_ACEOF
4194 /* confdefs.h.  */
4195 _ACEOF
4196 cat confdefs.h >>conftest.$ac_ext
4197 cat >>conftest.$ac_ext <<_ACEOF
4198 /* end confdefs.h.  */
4199 $ac_declaration
4200 int
4201 main ()
4202 {
4203 exit (42);
4204   ;
4205   return 0;
4206 }
4207 _ACEOF
4208 rm -f conftest.$ac_objext
4209 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4210   (eval $ac_compile) 2>conftest.er1
4211   ac_status=$?
4212   grep -v '^ *+' conftest.er1 >conftest.err
4213   rm -f conftest.er1
4214   cat conftest.err >&5
4215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4216   (exit $ac_status); } &&
4217          { ac_try='test -z "$ac_cxx_werror_flag"
4218                          || test ! -s conftest.err'
4219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4220   (eval $ac_try) 2>&5
4221   ac_status=$?
4222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4223   (exit $ac_status); }; } &&
4224          { ac_try='test -s conftest.$ac_objext'
4225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4226   (eval $ac_try) 2>&5
4227   ac_status=$?
4228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4229   (exit $ac_status); }; }; then
4230   break
4231 else
4232   echo "$as_me: failed program was:" >&5
4233 sed 's/^/| /' conftest.$ac_ext >&5
4234
4235 fi
4236 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4237 done
4238 rm -f conftest*
4239 if test -n "$ac_declaration"; then
4240   echo '#ifdef __cplusplus' >>confdefs.h
4241   echo $ac_declaration      >>confdefs.h
4242   echo '#endif'             >>confdefs.h
4243 fi
4244
4245 ac_ext=c
4246 ac_cpp='$CPP $CPPFLAGS'
4247 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4248 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4249 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4250
4251
4252 # We must set the default linker to the linker used by gcc for the correct
4253 # operation of libtool.  If LD is not defined and we are using gcc, try to
4254 # set the LD default to the ld used by gcc.
4255 if test -z "$LD"; then
4256   if test "$GCC" = yes; then
4257     case $build in
4258     *-*-mingw*)
4259       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4260     *)
4261       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4262     esac
4263     case $gcc_prog_ld in
4264     # Accept absolute paths.
4265     [\\/]* | [A-Za-z]:[\\/]*)
4266       LD="$gcc_prog_ld" ;;
4267     esac
4268   fi
4269 fi
4270
4271
4272
4273
4274 if test -n "$ac_tool_prefix"; then
4275   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4276 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4277 echo "$as_me:$LINENO: checking for $ac_word" >&5
4278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4279 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4280   echo $ECHO_N "(cached) $ECHO_C" >&6
4281 else
4282   if test -n "$GNATBIND"; then
4283   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4284 else
4285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4286 for as_dir in $PATH
4287 do
4288   IFS=$as_save_IFS
4289   test -z "$as_dir" && as_dir=.
4290   for ac_exec_ext in '' $ac_executable_extensions; do
4291   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4292     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4293     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4294     break 2
4295   fi
4296 done
4297 done
4298
4299 fi
4300 fi
4301 GNATBIND=$ac_cv_prog_GNATBIND
4302 if test -n "$GNATBIND"; then
4303   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4304 echo "${ECHO_T}$GNATBIND" >&6
4305 else
4306   echo "$as_me:$LINENO: result: no" >&5
4307 echo "${ECHO_T}no" >&6
4308 fi
4309
4310 fi
4311 if test -z "$ac_cv_prog_GNATBIND"; then
4312   ac_ct_GNATBIND=$GNATBIND
4313   # Extract the first word of "gnatbind", so it can be a program name with args.
4314 set dummy gnatbind; ac_word=$2
4315 echo "$as_me:$LINENO: checking for $ac_word" >&5
4316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4317 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4318   echo $ECHO_N "(cached) $ECHO_C" >&6
4319 else
4320   if test -n "$ac_ct_GNATBIND"; then
4321   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4322 else
4323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4324 for as_dir in $PATH
4325 do
4326   IFS=$as_save_IFS
4327   test -z "$as_dir" && as_dir=.
4328   for ac_exec_ext in '' $ac_executable_extensions; do
4329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4330     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4332     break 2
4333   fi
4334 done
4335 done
4336
4337   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4338 fi
4339 fi
4340 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4341 if test -n "$ac_ct_GNATBIND"; then
4342   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4343 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4344 else
4345   echo "$as_me:$LINENO: result: no" >&5
4346 echo "${ECHO_T}no" >&6
4347 fi
4348
4349   GNATBIND=$ac_ct_GNATBIND
4350 else
4351   GNATBIND="$ac_cv_prog_GNATBIND"
4352 fi
4353
4354 if test -n "$ac_tool_prefix"; then
4355   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4356 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4357 echo "$as_me:$LINENO: checking for $ac_word" >&5
4358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4359 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4360   echo $ECHO_N "(cached) $ECHO_C" >&6
4361 else
4362   if test -n "$GNATMAKE"; then
4363   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4364 else
4365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4366 for as_dir in $PATH
4367 do
4368   IFS=$as_save_IFS
4369   test -z "$as_dir" && as_dir=.
4370   for ac_exec_ext in '' $ac_executable_extensions; do
4371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4372     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4374     break 2
4375   fi
4376 done
4377 done
4378
4379 fi
4380 fi
4381 GNATMAKE=$ac_cv_prog_GNATMAKE
4382 if test -n "$GNATMAKE"; then
4383   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4384 echo "${ECHO_T}$GNATMAKE" >&6
4385 else
4386   echo "$as_me:$LINENO: result: no" >&5
4387 echo "${ECHO_T}no" >&6
4388 fi
4389
4390 fi
4391 if test -z "$ac_cv_prog_GNATMAKE"; then
4392   ac_ct_GNATMAKE=$GNATMAKE
4393   # Extract the first word of "gnatmake", so it can be a program name with args.
4394 set dummy gnatmake; ac_word=$2
4395 echo "$as_me:$LINENO: checking for $ac_word" >&5
4396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4397 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4398   echo $ECHO_N "(cached) $ECHO_C" >&6
4399 else
4400   if test -n "$ac_ct_GNATMAKE"; then
4401   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4402 else
4403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4404 for as_dir in $PATH
4405 do
4406   IFS=$as_save_IFS
4407   test -z "$as_dir" && as_dir=.
4408   for ac_exec_ext in '' $ac_executable_extensions; do
4409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4410     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4412     break 2
4413   fi
4414 done
4415 done
4416
4417   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4418 fi
4419 fi
4420 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4421 if test -n "$ac_ct_GNATMAKE"; then
4422   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4423 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4424 else
4425   echo "$as_me:$LINENO: result: no" >&5
4426 echo "${ECHO_T}no" >&6
4427 fi
4428
4429   GNATMAKE=$ac_ct_GNATMAKE
4430 else
4431   GNATMAKE="$ac_cv_prog_GNATMAKE"
4432 fi
4433
4434 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4435 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4436 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4437   echo $ECHO_N "(cached) $ECHO_C" >&6
4438 else
4439   cat >conftest.adb <<EOF
4440 procedure conftest is begin null; end conftest;
4441 EOF
4442 acx_cv_cc_gcc_supports_ada=no
4443 # There is a bug in old released versions of GCC which causes the
4444 # driver to exit successfully when the appropriate language module
4445 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4446 # Therefore we must check for the error message as well as an
4447 # unsuccessful exit.
4448 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4449 # given a .adb file, but produce no object file.  So we must check
4450 # if an object file was really produced to guard against this.
4451 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4452 if test x"$errors" = x && test -f conftest.$ac_objext; then
4453   acx_cv_cc_gcc_supports_ada=yes
4454 fi
4455 rm -f conftest.*
4456 fi
4457 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4458 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4459
4460 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4461   have_gnat=yes
4462 else
4463   have_gnat=no
4464 fi
4465
4466 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4467 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4468 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4469   echo $ECHO_N "(cached) $ECHO_C" >&6
4470 else
4471    echo abfoo >t1
4472   echo cdfoo >t2
4473   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4474   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4475     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4476       :
4477     else
4478       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4479     fi
4480   fi
4481   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4482     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4483       :
4484     else
4485       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4486     fi
4487   fi
4488   rm t1 t2
4489
4490 fi
4491 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4492 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4493 do_compare="$gcc_cv_prog_cmp_skip"
4494
4495
4496
4497 # Check for GMP and MPFR
4498 gmplibs="-lmpfr -lgmp"
4499 gmpinc=
4500 have_gmp=no
4501
4502 # Specify a location for mpfr
4503 # check for this first so it ends up on the link line before gmp.
4504
4505 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4506 if test "${with_mpfr_dir+set}" = set; then
4507   withval="$with_mpfr_dir"
4508   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4509 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4510 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4511 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4512    { (exit 1); exit 1; }; }
4513 fi;
4514
4515
4516 # Check whether --with-mpfr or --without-mpfr was given.
4517 if test "${with_mpfr+set}" = set; then
4518   withval="$with_mpfr"
4519
4520 fi;
4521
4522 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4523 if test "${with_mpfr_include+set}" = set; then
4524   withval="$with_mpfr_include"
4525
4526 fi;
4527
4528 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4529 if test "${with_mpfr_lib+set}" = set; then
4530   withval="$with_mpfr_lib"
4531
4532 fi;
4533
4534 if test "x$with_mpfr" != x; then
4535   gmplibs="-L$with_mpfr/lib $gmplibs"
4536   gmpinc="-I$with_mpfr/include"
4537 fi
4538 if test "x$with_mpfr_include" != x; then
4539   gmpinc="-I$with_mpfr_include"
4540 fi
4541 if test "x$with_mpfr_lib" != x; then
4542   gmplibs="-L$with_mpfr_lib $gmplibs"
4543 fi
4544 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4545   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4546   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4547   # Do not test the mpfr version.  Assume that it is sufficient, since
4548   # it is in the source tree, and the library has not been built yet
4549   # but it would be included on the link line in the version check below
4550   # hence making the test fail.
4551   have_gmp=yes
4552 fi
4553
4554 # Specify a location for gmp
4555
4556 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4557 if test "${with_gmp_dir+set}" = set; then
4558   withval="$with_gmp_dir"
4559   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4560 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4561 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4562 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4563    { (exit 1); exit 1; }; }
4564 fi;
4565
4566
4567 # Check whether --with-gmp or --without-gmp was given.
4568 if test "${with_gmp+set}" = set; then
4569   withval="$with_gmp"
4570
4571 fi;
4572
4573 # Check whether --with-gmp_include or --without-gmp_include was given.
4574 if test "${with_gmp_include+set}" = set; then
4575   withval="$with_gmp_include"
4576
4577 fi;
4578
4579 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4580 if test "${with_gmp_lib+set}" = set; then
4581   withval="$with_gmp_lib"
4582
4583 fi;
4584
4585
4586 if test "x$with_gmp" != x; then
4587   gmplibs="-L$with_gmp/lib $gmplibs"
4588   gmpinc="-I$with_gmp/include $gmpinc"
4589 fi
4590 if test "x$with_gmp_include" != x; then
4591   gmpinc="-I$with_gmp_include $gmpinc"
4592 fi
4593 if test "x$with_gmp_lib" != x; then
4594   gmplibs="-L$with_gmp_lib $gmplibs"
4595 fi
4596 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4597   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4598   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4599   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4600   # Do not test the gmp version.  Assume that it is sufficient, since
4601   # it is in the source tree, and the library has not been built yet
4602   # but it would be included on the link line in the version check below
4603   # hence making the test fail.
4604   have_gmp=yes
4605 fi
4606
4607 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4608   have_gmp=yes
4609   saved_CFLAGS="$CFLAGS"
4610   CFLAGS="$CFLAGS $gmpinc"
4611   # Check GMP actually works
4612   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4613 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4614
4615 cat >conftest.$ac_ext <<_ACEOF
4616 /* confdefs.h.  */
4617 _ACEOF
4618 cat confdefs.h >>conftest.$ac_ext
4619 cat >>conftest.$ac_ext <<_ACEOF
4620 /* end confdefs.h.  */
4621 #include "gmp.h"
4622 int
4623 main ()
4624 {
4625
4626   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4627   choke me
4628   #endif
4629
4630   ;
4631   return 0;
4632 }
4633 _ACEOF
4634 rm -f conftest.$ac_objext
4635 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4636   (eval $ac_compile) 2>conftest.er1
4637   ac_status=$?
4638   grep -v '^ *+' conftest.er1 >conftest.err
4639   rm -f conftest.er1
4640   cat conftest.err >&5
4641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4642   (exit $ac_status); } &&
4643          { ac_try='test -z "$ac_c_werror_flag"
4644                          || test ! -s conftest.err'
4645   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4646   (eval $ac_try) 2>&5
4647   ac_status=$?
4648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4649   (exit $ac_status); }; } &&
4650          { ac_try='test -s conftest.$ac_objext'
4651   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4652   (eval $ac_try) 2>&5
4653   ac_status=$?
4654   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4655   (exit $ac_status); }; }; then
4656   echo "$as_me:$LINENO: result: yes" >&5
4657 echo "${ECHO_T}yes" >&6
4658 else
4659   echo "$as_me: failed program was:" >&5
4660 sed 's/^/| /' conftest.$ac_ext >&5
4661
4662 echo "$as_me:$LINENO: result: no" >&5
4663 echo "${ECHO_T}no" >&6; have_gmp=no
4664 fi
4665 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4666
4667   if test x"$have_gmp" = xyes; then
4668     saved_LIBS="$LIBS"
4669     LIBS="$LIBS $gmplibs"
4670         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4671 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4672     cat >conftest.$ac_ext <<_ACEOF
4673 /* confdefs.h.  */
4674 _ACEOF
4675 cat confdefs.h >>conftest.$ac_ext
4676 cat >>conftest.$ac_ext <<_ACEOF
4677 /* end confdefs.h.  */
4678 #include <gmp.h>
4679     #include <mpfr.h>
4680 int
4681 main ()
4682 {
4683
4684     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4685     choke me
4686     #endif
4687     mpfr_t n;
4688     mpfr_t x;
4689     int t;
4690     mpfr_init (n);
4691     mpfr_init (x);
4692     mpfr_atan2 (n, n, x, GMP_RNDN);
4693     mpfr_erfc (n, x, GMP_RNDN);
4694     mpfr_subnormalize (x, t, GMP_RNDN);
4695
4696   ;
4697   return 0;
4698 }
4699 _ACEOF
4700 rm -f conftest.$ac_objext conftest$ac_exeext
4701 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4702   (eval $ac_link) 2>conftest.er1
4703   ac_status=$?
4704   grep -v '^ *+' conftest.er1 >conftest.err
4705   rm -f conftest.er1
4706   cat conftest.err >&5
4707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4708   (exit $ac_status); } &&
4709          { ac_try='test -z "$ac_c_werror_flag"
4710                          || test ! -s conftest.err'
4711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4712   (eval $ac_try) 2>&5
4713   ac_status=$?
4714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4715   (exit $ac_status); }; } &&
4716          { ac_try='test -s conftest$ac_exeext'
4717   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4718   (eval $ac_try) 2>&5
4719   ac_status=$?
4720   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4721   (exit $ac_status); }; }; then
4722   cat >conftest.$ac_ext <<_ACEOF
4723 /* confdefs.h.  */
4724 _ACEOF
4725 cat confdefs.h >>conftest.$ac_ext
4726 cat >>conftest.$ac_ext <<_ACEOF
4727 /* end confdefs.h.  */
4728 #include <gmp.h>
4729     #include <mpfr.h>
4730 int
4731 main ()
4732 {
4733
4734     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4735     choke me
4736     #endif
4737     mpfr_t n; mpfr_init(n);
4738
4739   ;
4740   return 0;
4741 }
4742 _ACEOF
4743 rm -f conftest.$ac_objext conftest$ac_exeext
4744 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4745   (eval $ac_link) 2>conftest.er1
4746   ac_status=$?
4747   grep -v '^ *+' conftest.er1 >conftest.err
4748   rm -f conftest.er1
4749   cat conftest.err >&5
4750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4751   (exit $ac_status); } &&
4752          { ac_try='test -z "$ac_c_werror_flag"
4753                          || test ! -s conftest.err'
4754   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4755   (eval $ac_try) 2>&5
4756   ac_status=$?
4757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4758   (exit $ac_status); }; } &&
4759          { ac_try='test -s conftest$ac_exeext'
4760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4761   (eval $ac_try) 2>&5
4762   ac_status=$?
4763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4764   (exit $ac_status); }; }; then
4765   echo "$as_me:$LINENO: result: yes" >&5
4766 echo "${ECHO_T}yes" >&6
4767 else
4768   echo "$as_me: failed program was:" >&5
4769 sed 's/^/| /' conftest.$ac_ext >&5
4770
4771 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4772 echo "${ECHO_T}buggy but acceptable" >&6
4773 fi
4774 rm -f conftest.err conftest.$ac_objext \
4775       conftest$ac_exeext conftest.$ac_ext
4776 else
4777   echo "$as_me: failed program was:" >&5
4778 sed 's/^/| /' conftest.$ac_ext >&5
4779
4780 echo "$as_me:$LINENO: result: no" >&5
4781 echo "${ECHO_T}no" >&6; have_gmp=no
4782 fi
4783 rm -f conftest.err conftest.$ac_objext \
4784       conftest$ac_exeext conftest.$ac_ext
4785       LIBS="$saved_LIBS"
4786   fi
4787   CFLAGS="$saved_CFLAGS"
4788
4789   if test x$have_gmp != xyes; then
4790     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4791 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4792 Copies of these libraries' source code can be found at their respective
4793 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4794 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4795 If you obtained GMP and/or MPFR from a vendor distribution package, make
4796 sure that you have installed both the libraries and the header files.
4797 They may be located in separate packages." >&5
4798 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4799 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4800 Copies of these libraries' source code can be found at their respective
4801 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4802 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4803 If you obtained GMP and/or MPFR from a vendor distribution package, make
4804 sure that you have installed both the libraries and the header files.
4805 They may be located in separate packages." >&2;}
4806    { (exit 1); exit 1; }; }
4807   fi
4808 fi
4809
4810 # Flags needed for both GMP and/or MPFR
4811
4812
4813
4814
4815 # Allow host libstdc++ to be specified for static linking with PPL.
4816
4817 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4818 if test "${with_host_libstdcxx+set}" = set; then
4819   withval="$with_host_libstdcxx"
4820
4821 fi;
4822
4823 case $with_host_libstdcxx in
4824   no|yes)
4825     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4826 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4827    { (exit 1); exit 1; }; }
4828     ;;
4829 esac
4830
4831 # Check for PPL
4832 ppl_major_version=0
4833 ppl_minor_version=10
4834 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4835 pplinc=
4836
4837
4838 # Check whether --with-ppl or --without-ppl was given.
4839 if test "${with_ppl+set}" = set; then
4840   withval="$with_ppl"
4841
4842 fi;
4843
4844 # Check whether --with-ppl_include or --without-ppl_include was given.
4845 if test "${with_ppl_include+set}" = set; then
4846   withval="$with_ppl_include"
4847
4848 fi;
4849
4850 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4851 if test "${with_ppl_lib+set}" = set; then
4852   withval="$with_ppl_lib"
4853
4854 fi;
4855
4856 case $with_ppl in
4857   no)
4858     ppllibs=
4859     ;;
4860   *)
4861     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4862     pplinc="-I$with_ppl/include $pplinc"
4863     LIBS="$ppllibs $LIBS"
4864     ;;
4865 esac
4866 if test "x$with_ppl_include" != x; then
4867   pplinc="-I$with_ppl_include $pplinc"
4868 fi
4869 if test "x$with_ppl_lib" != x; then
4870   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4871   LIBS="$ppllibs $LIBS"
4872 fi
4873 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4874   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4875   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4876   LIBS="$ppllibs $LIBS"
4877 fi
4878
4879 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4880 if test "${enable_ppl_version_check+set}" = set; then
4881   enableval="$enable_ppl_version_check"
4882   ENABLE_PPL_CHECK=$enableval
4883 else
4884   ENABLE_PPL_CHECK=yes
4885 fi;
4886
4887 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4888   saved_CFLAGS="$CFLAGS"
4889   CFLAGS="$CFLAGS $pplinc $gmpinc"
4890   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4891 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4892   cat >conftest.$ac_ext <<_ACEOF
4893 /* confdefs.h.  */
4894 _ACEOF
4895 cat confdefs.h >>conftest.$ac_ext
4896 cat >>conftest.$ac_ext <<_ACEOF
4897 /* end confdefs.h.  */
4898 #include "ppl_c.h"
4899 int
4900 main ()
4901 {
4902
4903   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4904   choke me
4905   #endif
4906
4907   ;
4908   return 0;
4909 }
4910 _ACEOF
4911 rm -f conftest.$ac_objext
4912 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4913   (eval $ac_compile) 2>conftest.er1
4914   ac_status=$?
4915   grep -v '^ *+' conftest.er1 >conftest.err
4916   rm -f conftest.er1
4917   cat conftest.err >&5
4918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4919   (exit $ac_status); } &&
4920          { ac_try='test -z "$ac_c_werror_flag"
4921                          || test ! -s conftest.err'
4922   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4923   (eval $ac_try) 2>&5
4924   ac_status=$?
4925   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4926   (exit $ac_status); }; } &&
4927          { ac_try='test -s conftest.$ac_objext'
4928   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4929   (eval $ac_try) 2>&5
4930   ac_status=$?
4931   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4932   (exit $ac_status); }; }; then
4933   echo "$as_me:$LINENO: result: yes" >&5
4934 echo "${ECHO_T}yes" >&6
4935 else
4936   echo "$as_me: failed program was:" >&5
4937 sed 's/^/| /' conftest.$ac_ext >&5
4938
4939 echo "$as_me:$LINENO: result: no" >&5
4940 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4941 fi
4942 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4943   CFLAGS="$saved_CFLAGS"
4944 fi
4945
4946 # Flags needed for PPL
4947
4948
4949
4950
4951 # Check for CLOOG
4952 clooglibs=" -lcloog "
4953 clooginc=" -DCLOOG_PPL_BACKEND "
4954
4955
4956 # Check whether --with-cloog or --without-cloog was given.
4957 if test "${with_cloog+set}" = set; then
4958   withval="$with_cloog"
4959
4960 fi;
4961
4962 # Check whether --with-cloog_include or --without-cloog_include was given.
4963 if test "${with_cloog_include+set}" = set; then
4964   withval="$with_cloog_include"
4965
4966 fi;
4967
4968 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4969 if test "${with_cloog_lib+set}" = set; then
4970   withval="$with_cloog_lib"
4971
4972 fi;
4973
4974 case $with_cloog in
4975   no)
4976     clooglibs=
4977     clooginc=
4978     ;;
4979   *)
4980     clooglibs="-L$with_cloog/lib -lcloog"
4981     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4982     LIBS="$clooglibs $LIBS"
4983     ;;
4984 esac
4985 if test "x$with_cloog_include" != x; then
4986   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4987 fi
4988 if test "x$with_cloog_lib" != x; then
4989   clooglibs="-L$with_cloog_lib -lcloog"
4990   LIBS="$clooglibs $LIBS"
4991 fi
4992 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4993   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4994   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4995   LIBS="$clooglibs $LIBS"
4996 fi
4997
4998 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4999 if test "${enable_cloog_version_check+set}" = set; then
5000   enableval="$enable_cloog_version_check"
5001   ENABLE_CLOOG_CHECK=$enableval
5002 else
5003   ENABLE_CLOOG_CHECK=yes
5004 fi;
5005
5006 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5007   saved_CFLAGS="$CFLAGS"
5008   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5009   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5010 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5011   cat >conftest.$ac_ext <<_ACEOF
5012 /* confdefs.h.  */
5013 _ACEOF
5014 cat confdefs.h >>conftest.$ac_ext
5015 cat >>conftest.$ac_ext <<_ACEOF
5016 /* end confdefs.h.  */
5017 #include "cloog/cloog.h"
5018 int
5019 main ()
5020 {
5021
5022   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5023   choke me
5024   #endif
5025
5026   ;
5027   return 0;
5028 }
5029 _ACEOF
5030 rm -f conftest.$ac_objext
5031 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5032   (eval $ac_compile) 2>conftest.er1
5033   ac_status=$?
5034   grep -v '^ *+' conftest.er1 >conftest.err
5035   rm -f conftest.er1
5036   cat conftest.err >&5
5037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5038   (exit $ac_status); } &&
5039          { ac_try='test -z "$ac_c_werror_flag"
5040                          || test ! -s conftest.err'
5041   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5042   (eval $ac_try) 2>&5
5043   ac_status=$?
5044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5045   (exit $ac_status); }; } &&
5046          { ac_try='test -s conftest.$ac_objext'
5047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5048   (eval $ac_try) 2>&5
5049   ac_status=$?
5050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5051   (exit $ac_status); }; }; then
5052   echo "$as_me:$LINENO: result: yes" >&5
5053 echo "${ECHO_T}yes" >&6
5054 else
5055   echo "$as_me: failed program was:" >&5
5056 sed 's/^/| /' conftest.$ac_ext >&5
5057
5058 echo "$as_me:$LINENO: result: no" >&5
5059 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5060 fi
5061 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5062   CFLAGS="$saved_CFLAGS"
5063 fi
5064
5065 # Flags needed for CLOOG
5066
5067
5068
5069
5070 # By default, C is the only stage 1 language.
5071 stage1_languages=,c,
5072
5073 # Figure out what language subdirectories are present.
5074 # Look if the user specified --enable-languages="..."; if not, use
5075 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5076 # go away some day.
5077 # NB:  embedded tabs in this IF block -- do not untabify
5078 if test -d ${srcdir}/gcc; then
5079   if test x"${enable_languages+set}" != xset; then
5080     if test x"${LANGUAGES+set}" = xset; then
5081       enable_languages="${LANGUAGES}"
5082         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5083     else
5084       enable_languages=all
5085     fi
5086   else
5087     if test x"${enable_languages}" = x ||
5088        test x"${enable_languages}" = xyes;
5089        then
5090       echo configure.in: --enable-languages needs at least one language argument 1>&2
5091       exit 1
5092     fi
5093   fi
5094   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5095
5096   # 'f95' is the old name for the 'fortran' language. We issue a warning
5097   # and make the substitution.
5098   case ,${enable_languages}, in
5099     *,f95,*)
5100       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5101       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5102       ;;
5103   esac
5104
5105   # First scan to see if an enabled language requires some other language.
5106   # We assume that a given config-lang.in will list all the language
5107   # front ends it requires, even if some are required indirectly.
5108   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5109     case ${lang_frag} in
5110       ..) ;;
5111       # The odd quoting in the next line works around
5112       # an apparent bug in bash 1.12 on linux.
5113       ${srcdir}/gcc/[*]/config-lang.in) ;;
5114       *)
5115         # From the config-lang.in, get $language, $lang_requires
5116         language=
5117         lang_requires=
5118         . ${lang_frag}
5119         for other in ${lang_requires} ; do
5120           case ,${enable_languages}, in
5121             *,$other,*) ;;
5122             *,all,*) ;;
5123             *,$language,*)
5124               echo " \`$other' language required by \`$language'; enabling" 1>&2
5125               enable_languages="${enable_languages},${other}"
5126               ;;
5127           esac
5128         done
5129         ;;
5130     esac
5131   done
5132
5133   new_enable_languages=,c,
5134   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5135   potential_languages=,c,
5136
5137   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5138     case ${lang_frag} in
5139       ..) ;;
5140       # The odd quoting in the next line works around
5141       # an apparent bug in bash 1.12 on linux.
5142       ${srcdir}/gcc/[*]/config-lang.in) ;;
5143       *)
5144         # From the config-lang.in, get $language, $target_libs,
5145         # $lang_dirs, $boot_language, and $build_by_default
5146         language=
5147         target_libs=
5148         lang_dirs=
5149         subdir_requires=
5150         boot_language=no
5151         build_by_default=yes
5152         . ${lang_frag}
5153         if test x${language} = x; then
5154           echo "${lang_frag} doesn't set \$language." 1>&2
5155           exit 1
5156         fi
5157
5158         case ,${enable_languages}, in
5159           *,${language},*)
5160             # Language was explicitly selected; include it.
5161             add_this_lang=yes
5162             ;;
5163           *,all,*)
5164             # 'all' was selected, select it if it is a default language
5165             add_this_lang=${build_by_default}
5166             ;;
5167           *)
5168             add_this_lang=no
5169             ;;
5170         esac
5171
5172         # Disable languages that need other directories if these aren't available.
5173         for i in $subdir_requires; do
5174           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5175           case ,${enable_languages}, in
5176             *,${language},*)
5177               # Specifically requested language; tell them.
5178               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5179 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5180    { (exit 1); exit 1; }; }
5181               ;;
5182             *)
5183               # Silently disable.
5184               add_this_lang=unsupported
5185               ;;
5186           esac
5187         done
5188
5189         # Disable Ada if no preexisting GNAT is available.
5190         case ,${enable_languages},:${language}:${have_gnat} in
5191           *,${language},*:ada:no)
5192             # Specifically requested language; tell them.
5193             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5194 echo "$as_me: error: GNAT is required to build $language" >&2;}
5195    { (exit 1); exit 1; }; }
5196             ;;
5197           *:ada:no)
5198             # Silently disable.
5199             add_this_lang=unsupported
5200             ;;
5201         esac
5202
5203         # Disable a language that is unsupported by the target.
5204         case " $unsupported_languages " in
5205           *" $language "*)
5206             add_this_lang=unsupported
5207             ;;
5208         esac
5209
5210         case $add_this_lang in
5211           unsupported)
5212             # Remove language-dependent dirs.
5213             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5214             ;;
5215           no)
5216             # Remove language-dependent dirs; still show language as supported.
5217             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5218             potential_languages="${potential_languages}${language},"
5219             ;;
5220           yes)
5221             new_enable_languages="${new_enable_languages}${language},"
5222             potential_languages="${potential_languages}${language},"
5223             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5224             case ${boot_language} in
5225               yes)
5226                 # Add to (comma-separated) list of stage 1 languages.
5227                 stage1_languages="${stage1_languages}${language},"
5228                 ;;
5229             esac
5230             ;;
5231         esac
5232         ;;
5233     esac
5234   done
5235
5236   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5237 if test "${enable_stage1_languages+set}" = set; then
5238   enableval="$enable_stage1_languages"
5239   case ,${enable_stage1_languages}, in
5240     ,no,|,,)
5241       # Set it to something that will have no effect in the loop below
5242       enable_stage1_languages=c ;;
5243     ,yes,)
5244       enable_stage1_languages=`echo $new_enable_languages | \
5245         sed -e "s/^,//" -e "s/,$//" ` ;;
5246     *,all,*)
5247       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5248         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5249   esac
5250
5251   # Add "good" languages from enable_stage1_languages to stage1_languages,
5252   # while "bad" languages go in missing_languages.  Leave no duplicates.
5253   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5254     case $potential_languages in
5255       *,$i,*)
5256         case $stage1_languages in
5257           *,$i,*) ;;
5258           *) stage1_languages="$stage1_languages$i," ;;
5259         esac ;;
5260       *)
5261         case $missing_languages in
5262           *,$i,*) ;;
5263           *) missing_languages="$missing_languages$i," ;;
5264         esac ;;
5265      esac
5266   done
5267 fi;
5268
5269   # Remove leading/trailing commas that were added for simplicity
5270   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5271   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5272   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5273   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5274
5275   if test "x$missing_languages" != x; then
5276     { { echo "$as_me:$LINENO: error:
5277 The following requested languages could not be built: ${missing_languages}
5278 Supported languages are: ${potential_languages}" >&5
5279 echo "$as_me: error:
5280 The following requested languages could not be built: ${missing_languages}
5281 Supported languages are: ${potential_languages}" >&2;}
5282    { (exit 1); exit 1; }; }
5283   fi
5284   if test "x$new_enable_languages" != "x$enable_languages"; then
5285     echo The following languages will be built: ${new_enable_languages}
5286     enable_languages="$new_enable_languages"
5287   fi
5288
5289
5290   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5291 fi
5292
5293 # Handle --disable-<component> generically.
5294 for dir in $configdirs $build_configdirs $target_configdirs ; do
5295   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5296   varname=`echo $dirname | sed -e s/+/_/g`
5297   if eval test x\${enable_${varname}} "=" xno ; then
5298     noconfigdirs="$noconfigdirs $dir"
5299   fi
5300 done
5301
5302 # Check for Boehm's garbage collector
5303 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5304 if test "${enable_objc_gc+set}" = set; then
5305   enableval="$enable_objc_gc"
5306   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5307   *,objc,*:*:yes:*target-boehm-gc*)
5308     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5309 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5310    { (exit 1); exit 1; }; }
5311     ;;
5312 esac
5313 fi;
5314
5315 # Make sure we only build Boehm's garbage collector if required.
5316 case ,${enable_languages},:${enable_objc_gc} in
5317   *,objc,*:yes)
5318     # Keep target-boehm-gc if requested for Objective-C.
5319     ;;
5320   *)
5321     # Otherwise remove target-boehm-gc depending on target-libjava.
5322     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5323       noconfigdirs="$noconfigdirs target-boehm-gc"
5324     fi
5325     ;;
5326 esac
5327
5328 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5329 # $build_configdirs and $target_configdirs.
5330 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5331
5332 notsupp=""
5333 for dir in . $skipdirs $noconfigdirs ; do
5334   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5335   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5336     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5337     if test -r $srcdir/$dirname/configure ; then
5338       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5339         true
5340       else
5341         notsupp="$notsupp $dir"
5342       fi
5343     fi
5344   fi
5345   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5346     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5347     if test -r $srcdir/$dirname/configure ; then
5348       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5349         true
5350       else
5351         notsupp="$notsupp $dir"
5352       fi
5353     fi
5354   fi
5355   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5356     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5357     if test -r $srcdir/$dirname/configure ; then
5358       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5359         true
5360       else
5361         notsupp="$notsupp $dir"
5362       fi
5363     fi
5364   fi
5365 done
5366
5367 # Sometimes the tools are distributed with libiberty but with no other
5368 # libraries.  In that case, we don't want to build target-libiberty.
5369 # Don't let libgcc imply libiberty either.
5370 if test -n "${target_configdirs}" ; then
5371   libgcc=
5372   others=
5373   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5374     if test "$i" = "libgcc"; then
5375       libgcc=target-libgcc
5376     elif test "$i" != "libiberty" ; then
5377       if test -r $srcdir/$i/configure ; then
5378         others=yes;
5379         break;
5380       fi
5381     fi
5382   done
5383   if test -z "${others}" ; then
5384     target_configdirs=$libgcc
5385   fi
5386 fi
5387
5388 # Quietly strip out all directories which aren't configurable in this tree.
5389 # This relies on all configurable subdirectories being autoconfiscated, which
5390 # is now the case.
5391 build_configdirs_all="$build_configdirs"
5392 build_configdirs=
5393 for i in ${build_configdirs_all} ; do
5394   j=`echo $i | sed -e s/build-//g`
5395   if test -f ${srcdir}/$j/configure ; then
5396     build_configdirs="${build_configdirs} $i"
5397   fi
5398 done
5399
5400 configdirs_all="$configdirs"
5401 configdirs=
5402 for i in ${configdirs_all} ; do
5403   if test -f ${srcdir}/$i/configure ; then
5404     configdirs="${configdirs} $i"
5405   fi
5406 done
5407
5408 target_configdirs_all="$target_configdirs"
5409 target_configdirs=
5410 for i in ${target_configdirs_all} ; do
5411   j=`echo $i | sed -e s/target-//g`
5412   if test -f ${srcdir}/$j/configure ; then
5413     target_configdirs="${target_configdirs} $i"
5414   fi
5415 done
5416
5417 # Produce a warning message for the subdirs we can't configure.
5418 # This isn't especially interesting in the Cygnus tree, but in the individual
5419 # FSF releases, it's important to let people know when their machine isn't
5420 # supported by the one or two programs in a package.
5421
5422 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5423   # If $appdirs is non-empty, at least one of those directories must still
5424   # be configured, or we error out.  (E.g., if the gas release supports a
5425   # specified target in some subdirs but not the gas subdir, we shouldn't
5426   # pretend that all is well.)
5427   if test -n "$appdirs" ; then
5428     for dir in $appdirs ; do
5429       if test -r $dir/Makefile.in ; then
5430         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5431           appdirs=""
5432           break
5433         fi
5434         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5435           appdirs=""
5436           break
5437         fi
5438       fi
5439     done
5440     if test -n "$appdirs" ; then
5441       echo "*** This configuration is not supported by this package." 1>&2
5442       exit 1
5443     fi
5444   fi
5445   # Okay, some application will build, or we don't care to check.  Still
5446   # notify of subdirs not getting built.
5447   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5448   echo "    ${notsupp}" 1>&2
5449   echo "    (Any other directories should still work fine.)" 1>&2
5450 fi
5451
5452 case "$host" in
5453   *msdosdjgpp*)
5454     enable_gdbtk=no ;;
5455 esac
5456
5457 # To find our prefix, in gcc_cv_tool_prefix.
5458
5459 # The user is always right.
5460 if test "${PATH_SEPARATOR+set}" != set; then
5461   echo "#! /bin/sh" >conf$$.sh
5462   echo  "exit 0"   >>conf$$.sh
5463   chmod +x conf$$.sh
5464   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5465     PATH_SEPARATOR=';'
5466   else
5467     PATH_SEPARATOR=:
5468   fi
5469   rm -f conf$$.sh
5470 fi
5471
5472
5473
5474 if test "x$exec_prefix" = xNONE; then
5475         if test "x$prefix" = xNONE; then
5476                 gcc_cv_tool_prefix=$ac_default_prefix
5477         else
5478                 gcc_cv_tool_prefix=$prefix
5479         fi
5480 else
5481         gcc_cv_tool_prefix=$exec_prefix
5482 fi
5483
5484 # If there is no compiler in the tree, use the PATH only.  In any
5485 # case, if there is no compiler in the tree nobody should use
5486 # AS_FOR_TARGET and LD_FOR_TARGET.
5487 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5488     gcc_version=`cat $srcdir/gcc/BASE-VER`
5489     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5490     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5491     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5492     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5493     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5494     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5495 else
5496     gcc_cv_tool_dirs=
5497 fi
5498
5499 if test x$build = x$target && test -n "$md_exec_prefix"; then
5500         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5501 fi
5502
5503
5504
5505 copy_dirs=
5506
5507
5508 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5509 if test "${with_build_sysroot+set}" = set; then
5510   withval="$with_build_sysroot"
5511   if test x"$withval" != x ; then
5512      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5513    fi
5514 else
5515   SYSROOT_CFLAGS_FOR_TARGET=
5516 fi;
5517
5518
5519
5520 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5521 if test "${with_debug_prefix_map+set}" = set; then
5522   withval="$with_debug_prefix_map"
5523   if test x"$withval" != x; then
5524      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5525      for debug_map in $withval; do
5526        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5527      done
5528    fi
5529 else
5530   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5531 fi;
5532
5533
5534 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5535 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5536 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5537 # We want to ensure that TARGET libraries (which we know are built with
5538 # gcc) are built with "-O2 -g", so include those options when setting
5539 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5540 if test "x$CFLAGS_FOR_TARGET" = x; then
5541   CFLAGS_FOR_TARGET=$CFLAGS
5542   case " $CFLAGS " in
5543     *" -O2 "*) ;;
5544     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5545   esac
5546   case " $CFLAGS " in
5547     *" -g "* | *" -g3 "*) ;;
5548     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5549   esac
5550 fi
5551
5552
5553 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5554   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5555   case " $CXXFLAGS " in
5556     *" -O2 "*) ;;
5557     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5558   esac
5559   case " $CXXFLAGS " in
5560     *" -g "* | *" -g3 "*) ;;
5561     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5562   esac
5563 fi
5564
5565
5566 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5567 # the named directory are copied to $(tooldir)/sys-include.
5568 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5569   if test x${is_cross_compiler} = xno ; then
5570     echo 1>&2 '***' --with-headers is only supported when cross compiling
5571     exit 1
5572   fi
5573   if test x"${with_headers}" != xyes ; then
5574     x=${gcc_cv_tool_prefix}
5575     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5576   fi
5577 fi
5578
5579 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5580 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5581 # are permitted.
5582 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5583   if test x${is_cross_compiler} = xno ; then
5584     echo 1>&2 '***' --with-libs is only supported when cross compiling
5585     exit 1
5586   fi
5587   if test x"${with_libs}" != xyes ; then
5588     # Copy the libraries in reverse order, so that files in the first named
5589     # library override files in subsequent libraries.
5590     x=${gcc_cv_tool_prefix}
5591     for l in ${with_libs}; do
5592       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5593     done
5594   fi
5595 fi
5596
5597 # Set with_gnu_as and with_gnu_ld as appropriate.
5598 #
5599 # This is done by determining whether or not the appropriate directory
5600 # is available, and by checking whether or not specific configurations
5601 # have requested that this magic not happen.
5602 #
5603 # The command line options always override the explicit settings in
5604 # configure.in, and the settings in configure.in override this magic.
5605 #
5606 # If the default for a toolchain is to use GNU as and ld, and you don't
5607 # want to do that, then you should use the --without-gnu-as and
5608 # --without-gnu-ld options for the configure script.
5609
5610 if test x${use_gnu_as} = x &&
5611    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5612   with_gnu_as=yes
5613   extra_host_args="$extra_host_args --with-gnu-as"
5614 fi
5615
5616 if test x${use_gnu_ld} = x &&
5617    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5618   with_gnu_ld=yes
5619   extra_host_args="$extra_host_args --with-gnu-ld"
5620 fi
5621
5622 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5623 # can detect this case.
5624
5625 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5626   with_newlib=yes
5627   extra_host_args="$extra_host_args --with-newlib"
5628 fi
5629
5630 # Handle ${copy_dirs}
5631 set fnord ${copy_dirs}
5632 shift
5633 while test $# != 0 ; do
5634   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5635     :
5636   else
5637     echo Copying $1 to $2
5638
5639     # Use the install script to create the directory and all required
5640     # parent directories.
5641     if test -d $2 ; then
5642       :
5643     else
5644       echo >config.temp
5645       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5646     fi
5647
5648     # Copy the directory, assuming we have tar.
5649     # FIXME: Should we use B in the second tar?  Not all systems support it.
5650     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5651
5652     # It is the responsibility of the user to correctly adjust all
5653     # symlinks.  If somebody can figure out how to handle them correctly
5654     # here, feel free to add the code.
5655
5656     echo $1 > $2/COPIED
5657   fi
5658   shift; shift
5659 done
5660
5661 # Determine a target-dependent exec_prefix that the installed
5662 # gcc will search in.  Keep this list sorted by triplet, with
5663 # the *-*-osname triplets last.
5664 md_exec_prefix=
5665 case "${target}" in
5666   alpha*-*-*vms*)
5667     md_exec_prefix=/gnu/lib/gcc-lib
5668     ;;
5669   i[34567]86-pc-msdosdjgpp*)
5670     md_exec_prefix=/dev/env/DJDIR/bin
5671     ;;
5672   i[34567]86-*-sco3.2v5*)
5673     if test $with_gnu_as = yes; then
5674       md_exec_prefix=/usr/gnu/bin
5675     else
5676       md_exec_prefix=/usr/ccs/bin/elf
5677     fi
5678     ;;
5679
5680   mn10300-*-* | \
5681   powerpc-*-chorusos* | \
5682   powerpc*-*-eabi* | \
5683   powerpc*-*-sysv* | \
5684   powerpc*-*-kaos* | \
5685   s390x-ibm-tpf*)
5686     md_exec_prefix=/usr/ccs/bin
5687     ;;
5688   sparc64-*-elf*)
5689     ;;
5690   v850*-*-*)
5691     md_exec_prefix=/usr/ccs/bin
5692     ;;
5693   xtensa*-*-elf*)
5694     ;;
5695
5696   *-*-beos* | \
5697   *-*-elf* | \
5698   *-*-hpux* | \
5699   *-*-netware* | \
5700   *-*-nto-qnx* | \
5701   *-*-rtems* | \
5702   *-*-solaris2* | \
5703   *-*-sysv[45]* | \
5704   *-*-vxworks* | \
5705   *-wrs-windiss)
5706     md_exec_prefix=/usr/ccs/bin
5707     ;;
5708 esac
5709
5710 extra_arflags_for_target=
5711 extra_nmflags_for_target=
5712 extra_ranlibflags_for_target=
5713 target_makefile_frag=/dev/null
5714 case "${target}" in
5715   mep*-*-*)
5716     target_makefile_frag="config/mt-mep"
5717     ;;
5718   spu-*-*)
5719     target_makefile_frag="config/mt-spu"
5720     ;;
5721   mips*-sde-elf*)
5722     target_makefile_frag="config/mt-sde"
5723     ;;
5724   mipsisa*-*-elfoabi*)
5725     target_makefile_frag="config/mt-mips-elfoabi"
5726     ;;
5727   mips*-*-*linux* | mips*-*-gnu*)
5728     target_makefile_frag="config/mt-mips-gnu"
5729     ;;
5730   *-*-netware*)
5731     target_makefile_frag="config/mt-netware"
5732     ;;
5733   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5734     target_makefile_frag="config/mt-gnu"
5735     ;;
5736   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5737     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5738     # commands to handle both 32-bit and 64-bit objects.  These flags are
5739     # harmless if we're using GNU nm or ar.
5740     extra_arflags_for_target=" -X32_64"
5741     extra_nmflags_for_target=" -B -X32_64"
5742     ;;
5743   *-*-darwin*)
5744     # ranlib from Darwin requires the -c flag to look at common symbols.
5745     extra_ranlibflags_for_target=" -c"
5746     ;;
5747   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5748     target_makefile_frag="config/mt-wince"
5749     ;;
5750 esac
5751
5752 alphaieee_frag=/dev/null
5753 case $target in
5754   alpha*-*-*)
5755     # This just makes sure to use the -mieee option to build target libs.
5756     # This should probably be set individually by each library.
5757     alphaieee_frag="config/mt-alphaieee"
5758     ;;
5759 esac
5760
5761 # If --enable-target-optspace always use -Os instead of -O2 to build
5762 # the target libraries, similarly if it is not specified, use -Os
5763 # on selected platforms.
5764 ospace_frag=/dev/null
5765 case "${enable_target_optspace}:${target}" in
5766   yes:*)
5767     ospace_frag="config/mt-ospace"
5768     ;;
5769   :d30v-*)
5770     ospace_frag="config/mt-d30v"
5771     ;;
5772   :m32r-* | :d10v-* | :fr30-*)
5773     ospace_frag="config/mt-ospace"
5774     ;;
5775   no:* | :*)
5776     ;;
5777   *)
5778     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5779     ;;
5780 esac
5781
5782 # Default to using --with-stabs for certain targets.
5783 if test x${with_stabs} = x ; then
5784   case "${target}" in
5785   mips*-*-irix[56]*)
5786     ;;
5787   mips*-*-* | alpha*-*-osf*)
5788     with_stabs=yes;
5789     extra_host_args="${extra_host_args} --with-stabs"
5790     ;;
5791   esac
5792 fi
5793
5794 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5795 # them automatically.
5796 case "${host}" in
5797   hppa*64*-*-hpux11*)
5798     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5799     ;;
5800 esac
5801
5802 # Some systems (e.g., one of the i386-aix systems the gas testers are
5803 # using) don't handle "\$" correctly, so don't use it here.
5804 tooldir='${exec_prefix}'/${target_noncanonical}
5805 build_tooldir=${tooldir}
5806
5807 # Create a .gdbinit file which runs the one in srcdir
5808 # and tells GDB to look there for source files.
5809
5810 if test -r ${srcdir}/.gdbinit ; then
5811   case ${srcdir} in
5812     .) ;;
5813     *) cat > ./.gdbinit <<EOF
5814 # ${NO_EDIT}
5815 dir ${srcdir}
5816 dir .
5817 source ${srcdir}/.gdbinit
5818 EOF
5819     ;;
5820   esac
5821 fi
5822
5823 # Make sure that the compiler is able to generate an executable.  If it
5824 # can't, we are probably in trouble.  We don't care whether we can run the
5825 # executable--we might be using a cross compiler--we only care whether it
5826 # can be created.  At this point the main configure script has set CC.
5827 we_are_ok=no
5828 echo "int main () { return 0; }" > conftest.c
5829 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5830 if test $? = 0 ; then
5831   if test -s conftest || test -s conftest.exe ; then
5832     we_are_ok=yes
5833   fi
5834 fi
5835 case $we_are_ok in
5836   no)
5837     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5838     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5839     rm -f conftest*
5840     exit 1
5841     ;;
5842 esac
5843 rm -f conftest*
5844
5845 # The Solaris /usr/ucb/cc compiler does not appear to work.
5846 case "${host}" in
5847   sparc-sun-solaris2*)
5848       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5849       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5850           could_use=
5851           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5852           if test -d /opt/cygnus/bin ; then
5853               if test "$could_use" = "" ; then
5854                   could_use="/opt/cygnus/bin"
5855               else
5856                   could_use="$could_use or /opt/cygnus/bin"
5857               fi
5858           fi
5859         if test "$could_use" = "" ; then
5860             echo "Warning: compilation may fail because you're using"
5861             echo "/usr/ucb/cc.  You should change your PATH or CC "
5862             echo "variable and rerun configure."
5863         else
5864             echo "Warning: compilation may fail because you're using"
5865             echo "/usr/ucb/cc, when you should use the C compiler from"
5866             echo "$could_use.  You should change your"
5867             echo "PATH or CC variable and rerun configure."
5868         fi
5869       fi
5870   ;;
5871 esac
5872
5873 # Decide which environment variable is used to find dynamic libraries.
5874 case "${host}" in
5875   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5876   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5877   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5878   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5879 esac
5880
5881 # On systems where the dynamic library environment variable is PATH,
5882 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5883 # built executables to PATH.
5884 if test "$RPATH_ENVVAR" = PATH; then
5885   GCC_SHLIB_SUBDIR=/shlib
5886 else
5887   GCC_SHLIB_SUBDIR=
5888 fi
5889
5890 # Record target_configdirs and the configure arguments for target and
5891 # build configuration in Makefile.
5892 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5893 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5894
5895 # Determine whether gdb needs tk/tcl or not.
5896 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5897 # and in that case we want gdb to be built without tk.  Ugh!
5898 # In fact I believe gdb is the *only* package directly dependent on tk,
5899 # so we should be able to put the 'maybe's in unconditionally and
5900 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5901 # 100% sure that that's safe though.
5902
5903 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5904 case "$enable_gdbtk" in
5905   no)
5906     GDB_TK="" ;;
5907   yes)
5908     GDB_TK="${gdb_tk}" ;;
5909   *)
5910     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5911     # distro.  Eventually someone will fix this and move Insight, nee
5912     # gdbtk to a separate directory.
5913     if test -d ${srcdir}/gdb/gdbtk ; then
5914       GDB_TK="${gdb_tk}"
5915     else
5916       GDB_TK=""
5917     fi
5918     ;;
5919 esac
5920 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5921 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5922
5923 # Strip out unwanted targets.
5924
5925 # While at that, we remove Makefiles if we were started for recursive
5926 # configuration, so that the top-level Makefile reconfigures them,
5927 # like we used to do when configure itself was recursive.
5928
5929 # Loop over modules.  $extrasub must be used with care, limiting as
5930 # much as possible the usage of range addresses.  That's because autoconf
5931 # splits the sed script to overcome limits in the number of commands,
5932 # and relying on carefully-timed sed passes may turn out to be very hard
5933 # to maintain later.  In this particular case, you just have to be careful
5934 # not to nest @if/@endif pairs, because configure will not warn you at all.
5935
5936 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5937 if test "${enable_bootstrap+set}" = set; then
5938   enableval="$enable_bootstrap"
5939
5940 else
5941   enable_bootstrap=default
5942 fi;
5943
5944 # Issue errors and warnings for invalid/strange bootstrap combinations.
5945 case "$configdirs" in
5946   *gcc*) have_compiler=yes ;;
5947   *) have_compiler=no ;;
5948 esac
5949
5950 case "$have_compiler:$host:$target:$enable_bootstrap" in
5951   *:*:*:no) ;;
5952
5953   # Default behavior.  Enable bootstrap if we have a compiler
5954   # and we are in a native configuration.
5955   yes:$build:$build:default)
5956     enable_bootstrap=yes ;;
5957
5958   *:*:*:default)
5959     enable_bootstrap=no ;;
5960
5961   # We have a compiler and we are in a native configuration, bootstrap is ok
5962   yes:$build:$build:yes)
5963     ;;
5964
5965   # Other configurations, but we have a compiler.  Assume the user knows
5966   # what he's doing.
5967   yes:*:*:yes)
5968     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5969 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5970     ;;
5971
5972   # No compiler: if they passed --enable-bootstrap explicitly, fail
5973   no:*:*:yes)
5974     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5975 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5976    { (exit 1); exit 1; }; } ;;
5977
5978   # Fail if wrong command line
5979   *)
5980     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5981 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5982    { (exit 1); exit 1; }; }
5983     ;;
5984 esac
5985
5986 # Adjust the toplevel makefile according to whether bootstrap was selected.
5987 case "$enable_bootstrap" in
5988   yes)
5989     bootstrap_suffix=bootstrap ;;
5990   no)
5991     bootstrap_suffix=no-bootstrap ;;
5992 esac
5993
5994 for module in ${build_configdirs} ; do
5995   if test -z "${no_recursion}" \
5996      && test -f ${build_subdir}/${module}/Makefile; then
5997     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5998     rm -f ${build_subdir}/${module}/Makefile
5999   fi
6000   extrasub="$extrasub
6001 /^@if build-$module\$/d
6002 /^@endif build-$module\$/d
6003 /^@if build-$module-$bootstrap_suffix\$/d
6004 /^@endif build-$module-$bootstrap_suffix\$/d"
6005 done
6006 for module in ${configdirs} ; do
6007   if test -z "${no_recursion}"; then
6008     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6009       if test -f ${file}; then
6010         echo 1>&2 "*** removing ${file} to force reconfigure"
6011         rm -f ${file}
6012       fi
6013     done
6014   fi
6015   extrasub="$extrasub
6016 /^@if $module\$/d
6017 /^@endif $module\$/d
6018 /^@if $module-$bootstrap_suffix\$/d
6019 /^@endif $module-$bootstrap_suffix\$/d"
6020 done
6021 for module in ${target_configdirs} ; do
6022   if test -z "${no_recursion}" \
6023      && test -f ${target_subdir}/${module}/Makefile; then
6024     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6025     rm -f ${target_subdir}/${module}/Makefile
6026   fi
6027   extrasub="$extrasub
6028 /^@if target-$module\$/d
6029 /^@endif target-$module\$/d
6030 /^@if target-$module-$bootstrap_suffix\$/d
6031 /^@endif target-$module-$bootstrap_suffix\$/d"
6032 done
6033
6034 extrasub="$extrasub
6035 /^@if /,/^@endif /d"
6036
6037 # Create the serialization dependencies.  This uses a temporary file.
6038
6039 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6040 if test "${enable_serial_configure+set}" = set; then
6041   enableval="$enable_serial_configure"
6042
6043 fi;
6044
6045 case ${enable_serial_configure} in
6046   yes)
6047     enable_serial_build_configure=yes
6048     enable_serial_host_configure=yes
6049     enable_serial_target_configure=yes
6050     ;;
6051 esac
6052
6053 # These force 'configure's to be done one at a time, to avoid problems
6054 # with contention over a shared config.cache.
6055 rm -f serdep.tmp
6056 echo '# serdep.tmp' > serdep.tmp
6057 olditem=
6058 test "x${enable_serial_build_configure}" = xyes &&
6059 for item in ${build_configdirs} ; do
6060   case ${olditem} in
6061     "") ;;
6062     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6063   esac
6064   olditem=${item}
6065 done
6066 olditem=
6067 test "x${enable_serial_host_configure}" = xyes &&
6068 for item in ${configdirs} ; do
6069   case ${olditem} in
6070     "") ;;
6071     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6072   esac
6073   olditem=${item}
6074 done
6075 olditem=
6076 test "x${enable_serial_target_configure}" = xyes &&
6077 for item in ${target_configdirs} ; do
6078   case ${olditem} in
6079     "") ;;
6080     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6081   esac
6082   olditem=${item}
6083 done
6084 serialization_dependencies=serdep.tmp
6085
6086
6087 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6088 # target, nonopt, and variable assignments.  These are the ones we
6089 # might not want to pass down to subconfigures.  Also strip
6090 # program-prefix, program-suffix, and program-transform-name, so that
6091 # we can pass down a consistent program-transform-name.
6092 baseargs=
6093 keep_next=no
6094 skip_next=no
6095 eval "set -- $ac_configure_args"
6096 for ac_arg
6097 do
6098   if test X"$skip_next" = X"yes"; then
6099     skip_next=no
6100     continue
6101   fi
6102   if test X"$keep_next" = X"yes"; then
6103     case $ac_arg in
6104       *\'*)
6105         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6106     esac
6107     baseargs="$baseargs '$ac_arg'"
6108     keep_next=no
6109     continue
6110   fi
6111
6112   # Handle separated arguments.  Based on the logic generated by
6113   # autoconf 2.59.
6114   case $ac_arg in
6115     *=* | --config-cache | -C | -disable-* | --disable-* \
6116       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6117       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6118       | -with-* | --with-* | -without-* | --without-* | --x)
6119       separate_arg=no
6120       ;;
6121     -*)
6122       separate_arg=yes
6123       ;;
6124     *)
6125       separate_arg=no
6126       ;;
6127   esac
6128
6129   case "$ac_arg" in
6130     --no*)
6131       continue
6132       ;;
6133     --c* | \
6134     --sr* | \
6135     --ho* | \
6136     --bu* | \
6137     --t* | \
6138     --program-* | \
6139     -cache_file* | \
6140     -srcdir* | \
6141     -host* | \
6142     -build* | \
6143     -target* | \
6144     -program-prefix* | \
6145     -program-suffix* | \
6146     -program-transform-name* )
6147       skip_next=$separate_arg
6148       continue
6149       ;;
6150     -*)
6151       # An option.  Add it.
6152       case $ac_arg in
6153         *\'*)
6154           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6155       esac
6156       baseargs="$baseargs '$ac_arg'"
6157       keep_next=$separate_arg
6158       ;;
6159     *)
6160       # Either a variable assignment, or a nonopt (triplet).  Don't
6161       # pass it down; let the Makefile handle this.
6162       continue
6163       ;;
6164   esac
6165 done
6166 # Remove the initial space we just introduced and, as these will be
6167 # expanded by make, quote '$'.
6168 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6169
6170 # Add in --program-transform-name, after --program-prefix and
6171 # --program-suffix have been applied to it.  Autoconf has already
6172 # doubled dollar signs and backslashes in program_transform_name; we want
6173 # the backslashes un-doubled, and then the entire thing wrapped in single
6174 # quotes, because this will be expanded first by make and then by the shell.
6175 # Also, because we want to override the logic in subdir configure scripts to
6176 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6177 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6178 ${program_transform_name}
6179 EOF_SED
6180 gcc_transform_name=`cat conftestsed.out`
6181 rm -f conftestsed.out
6182 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6183 if test "$silent" = yes; then
6184   baseargs="$baseargs --silent"
6185 fi
6186
6187 # For the build-side libraries, we just need to pretend we're native,
6188 # and not use the same cache file.  Multilibs are neither needed nor
6189 # desired.
6190 build_configargs="--cache-file=../config.cache ${baseargs}"
6191
6192 # For host modules, accept cache file option, or specification as blank.
6193 case "${cache_file}" in
6194 "") # empty
6195   cache_file_option="" ;;
6196 /* | [A-Za-z]:[\\/]* ) # absolute path
6197   cache_file_option="--cache-file=${cache_file}" ;;
6198 *) # relative path
6199   cache_file_option="--cache-file=../${cache_file}" ;;
6200 esac
6201
6202 # Host dirs don't like to share a cache file either, horribly enough.
6203 # This seems to be due to autoconf 2.5x stupidity.
6204 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6205
6206 target_configargs=${baseargs}
6207
6208 # Passing a --with-cross-host argument lets the target libraries know
6209 # whether they are being built with a cross-compiler or being built
6210 # native.  However, it would be better to use other mechanisms to make the
6211 # sorts of decisions they want to make on this basis.  Please consider
6212 # this option to be deprecated.  FIXME.
6213 if test x${is_cross_compiler} = xyes ; then
6214   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6215 fi
6216
6217 # Default to --enable-multilib.
6218 if test x${enable_multilib} = x ; then
6219   target_configargs="--enable-multilib ${target_configargs}"
6220 fi
6221
6222 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6223 # changed from the earlier setting of with_newlib.
6224 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6225   target_configargs="--with-newlib ${target_configargs}"
6226 fi
6227
6228 # Different target subdirs use different values of certain variables
6229 # (notably CXX).  Worse, multilibs use *lots* of different values.
6230 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6231 # it doesn't automatically accept command-line overrides of them.
6232 # This means it's not safe for target subdirs to share a cache file,
6233 # which is disgusting, but there you have it.  Hopefully this can be
6234 # fixed in future.  It's still worthwhile to use a cache file for each
6235 # directory.  I think.
6236
6237 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6238 # We need to pass --target, as newer autoconf's requires consistency
6239 # for target_alias and gcc doesn't manage it consistently.
6240 target_configargs="--cache-file=./config.cache ${target_configargs}"
6241
6242 FLAGS_FOR_TARGET=
6243 case " $target_configdirs " in
6244  *" newlib "*)
6245   case " $target_configargs " in
6246   *" --with-newlib "*)
6247    case "$target" in
6248    *-cygwin*)
6249      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' ;;
6250    esac
6251
6252    # If we're not building GCC, don't discard standard headers.
6253    if test -d ${srcdir}/gcc; then
6254      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6255
6256      if test "${build}" != "${host}"; then
6257        # On Canadian crosses, CC_FOR_TARGET will have already been set
6258        # by `configure', so we won't have an opportunity to add -Bgcc/
6259        # to it.  This is right: we don't want to search that directory
6260        # for binaries, but we want the header files in there, so add
6261        # them explicitly.
6262        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6263
6264        # Someone might think of using the pre-installed headers on
6265        # Canadian crosses, in case the installed compiler is not fully
6266        # compatible with the compiler being built.  In this case, it
6267        # would be better to flag an error than risking having
6268        # incompatible object files being constructed.  We can't
6269        # guarantee that an error will be flagged, but let's hope the
6270        # compiler will do it, when presented with incompatible header
6271        # files.
6272      fi
6273    fi
6274
6275    case "${target}-${is_cross_compiler}" in
6276    i[3456789]86-*-linux*-no)
6277       # Here host == target, so we don't need to build gcc,
6278       # so we don't want to discard standard headers.
6279       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6280       ;;
6281    *)
6282       # If we're building newlib, use its generic headers last, but search
6283       # for any libc-related directories first (so make it the last -B
6284       # switch).
6285       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6286
6287       # If we're building libgloss, find the startup file, simulator library
6288       # and linker script.
6289       case " $target_configdirs " in
6290         *" libgloss "*)
6291         # Look for startup file, simulator library and maybe linker script.
6292         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6293         # Look for libnosys.a in case the target needs it.
6294         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6295         # Most targets have the linker script in the source directory.
6296         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6297         ;;
6298       esac
6299       ;;
6300    esac
6301    ;;
6302   esac
6303   ;;
6304 esac
6305 case "$target" in
6306 *-mingw*)
6307   # Can't be handled as Cygwin above since Mingw does not use newlib.
6308   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' ;;
6309 esac
6310
6311 # Allow the user to override the flags for
6312 # our build compiler if desired.
6313 if test x"${build}" = x"${host}" ; then
6314   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6315   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6316   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6317 fi
6318
6319 # On Canadian crosses, we'll be searching the right directories for
6320 # the previously-installed cross compiler, so don't bother to add
6321 # flags for directories within the install tree of the compiler
6322 # being built; programs in there won't even run.
6323 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6324   # Search for pre-installed headers if nothing else fits.
6325   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6326 fi
6327
6328 if test "x${use_gnu_ld}" = x &&
6329    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6330   # Arrange for us to find uninstalled linker scripts.
6331   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6332 fi
6333
6334 # Search for other target-specific linker scripts and such.
6335 case "${target}" in
6336   mep*)
6337     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6338     ;;
6339 esac
6340
6341 # Makefile fragments.
6342 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6343 do
6344   eval fragval=\$$frag
6345   if test $fragval != /dev/null; then
6346     eval $frag=${srcdir}/$fragval
6347   fi
6348 done
6349
6350
6351
6352
6353
6354 # Miscellanea: directories, flags, etc.
6355
6356
6357
6358
6359
6360
6361
6362
6363 # Build module lists & subconfigure args.
6364
6365
6366
6367 # Host module lists & subconfigure args.
6368
6369
6370
6371 # Target module lists & subconfigure args.
6372
6373
6374
6375 # Build tools.
6376
6377
6378
6379
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393 # Generate default definitions for YACC, M4, LEX and other programs that run
6394 # on the build machine.  These are used if the Makefile can't locate these
6395 # programs in objdir.
6396 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6397
6398 for ac_prog in 'bison -y' byacc yacc
6399 do
6400   # Extract the first word of "$ac_prog", so it can be a program name with args.
6401 set dummy $ac_prog; ac_word=$2
6402 echo "$as_me:$LINENO: checking for $ac_word" >&5
6403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6404 if test "${ac_cv_prog_YACC+set}" = set; then
6405   echo $ECHO_N "(cached) $ECHO_C" >&6
6406 else
6407   if test -n "$YACC"; then
6408   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6409 else
6410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6411 for as_dir in $PATH
6412 do
6413   IFS=$as_save_IFS
6414   test -z "$as_dir" && as_dir=.
6415   for ac_exec_ext in '' $ac_executable_extensions; do
6416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6417     ac_cv_prog_YACC="$ac_prog"
6418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6419     break 2
6420   fi
6421 done
6422 done
6423
6424 fi
6425 fi
6426 YACC=$ac_cv_prog_YACC
6427 if test -n "$YACC"; then
6428   echo "$as_me:$LINENO: result: $YACC" >&5
6429 echo "${ECHO_T}$YACC" >&6
6430 else
6431   echo "$as_me:$LINENO: result: no" >&5
6432 echo "${ECHO_T}no" >&6
6433 fi
6434
6435   test -n "$YACC" && break
6436 done
6437 test -n "$YACC" || YACC="$MISSING bison -y"
6438
6439 case " $build_configdirs " in
6440   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6441   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6442 esac
6443
6444 for ac_prog in bison
6445 do
6446   # Extract the first word of "$ac_prog", so it can be a program name with args.
6447 set dummy $ac_prog; ac_word=$2
6448 echo "$as_me:$LINENO: checking for $ac_word" >&5
6449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6450 if test "${ac_cv_prog_BISON+set}" = set; then
6451   echo $ECHO_N "(cached) $ECHO_C" >&6
6452 else
6453   if test -n "$BISON"; then
6454   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6455 else
6456 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6457 for as_dir in $PATH
6458 do
6459   IFS=$as_save_IFS
6460   test -z "$as_dir" && as_dir=.
6461   for ac_exec_ext in '' $ac_executable_extensions; do
6462   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6463     ac_cv_prog_BISON="$ac_prog"
6464     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6465     break 2
6466   fi
6467 done
6468 done
6469
6470 fi
6471 fi
6472 BISON=$ac_cv_prog_BISON
6473 if test -n "$BISON"; then
6474   echo "$as_me:$LINENO: result: $BISON" >&5
6475 echo "${ECHO_T}$BISON" >&6
6476 else
6477   echo "$as_me:$LINENO: result: no" >&5
6478 echo "${ECHO_T}no" >&6
6479 fi
6480
6481   test -n "$BISON" && break
6482 done
6483 test -n "$BISON" || BISON="$MISSING bison"
6484
6485 case " $build_configdirs " in
6486   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6487 esac
6488
6489 for ac_prog in gm4 gnum4 m4
6490 do
6491   # Extract the first word of "$ac_prog", so it can be a program name with args.
6492 set dummy $ac_prog; ac_word=$2
6493 echo "$as_me:$LINENO: checking for $ac_word" >&5
6494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6495 if test "${ac_cv_prog_M4+set}" = set; then
6496   echo $ECHO_N "(cached) $ECHO_C" >&6
6497 else
6498   if test -n "$M4"; then
6499   ac_cv_prog_M4="$M4" # Let the user override the test.
6500 else
6501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6502 for as_dir in $PATH
6503 do
6504   IFS=$as_save_IFS
6505   test -z "$as_dir" && as_dir=.
6506   for ac_exec_ext in '' $ac_executable_extensions; do
6507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6508     ac_cv_prog_M4="$ac_prog"
6509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6510     break 2
6511   fi
6512 done
6513 done
6514
6515 fi
6516 fi
6517 M4=$ac_cv_prog_M4
6518 if test -n "$M4"; then
6519   echo "$as_me:$LINENO: result: $M4" >&5
6520 echo "${ECHO_T}$M4" >&6
6521 else
6522   echo "$as_me:$LINENO: result: no" >&5
6523 echo "${ECHO_T}no" >&6
6524 fi
6525
6526   test -n "$M4" && break
6527 done
6528 test -n "$M4" || M4="$MISSING m4"
6529
6530 case " $build_configdirs " in
6531   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6532 esac
6533
6534 for ac_prog in flex lex
6535 do
6536   # Extract the first word of "$ac_prog", so it can be a program name with args.
6537 set dummy $ac_prog; ac_word=$2
6538 echo "$as_me:$LINENO: checking for $ac_word" >&5
6539 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6540 if test "${ac_cv_prog_LEX+set}" = set; then
6541   echo $ECHO_N "(cached) $ECHO_C" >&6
6542 else
6543   if test -n "$LEX"; then
6544   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6545 else
6546 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6547 for as_dir in $PATH
6548 do
6549   IFS=$as_save_IFS
6550   test -z "$as_dir" && as_dir=.
6551   for ac_exec_ext in '' $ac_executable_extensions; do
6552   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6553     ac_cv_prog_LEX="$ac_prog"
6554     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6555     break 2
6556   fi
6557 done
6558 done
6559
6560 fi
6561 fi
6562 LEX=$ac_cv_prog_LEX
6563 if test -n "$LEX"; then
6564   echo "$as_me:$LINENO: result: $LEX" >&5
6565 echo "${ECHO_T}$LEX" >&6
6566 else
6567   echo "$as_me:$LINENO: result: no" >&5
6568 echo "${ECHO_T}no" >&6
6569 fi
6570
6571   test -n "$LEX" && break
6572 done
6573 test -n "$LEX" || LEX="$MISSING flex"
6574
6575 case " $build_configdirs " in
6576   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6577   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6578 esac
6579
6580 for ac_prog in flex
6581 do
6582   # Extract the first word of "$ac_prog", so it can be a program name with args.
6583 set dummy $ac_prog; ac_word=$2
6584 echo "$as_me:$LINENO: checking for $ac_word" >&5
6585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6586 if test "${ac_cv_prog_FLEX+set}" = set; then
6587   echo $ECHO_N "(cached) $ECHO_C" >&6
6588 else
6589   if test -n "$FLEX"; then
6590   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6591 else
6592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6593 for as_dir in $PATH
6594 do
6595   IFS=$as_save_IFS
6596   test -z "$as_dir" && as_dir=.
6597   for ac_exec_ext in '' $ac_executable_extensions; do
6598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6599     ac_cv_prog_FLEX="$ac_prog"
6600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6601     break 2
6602   fi
6603 done
6604 done
6605
6606 fi
6607 fi
6608 FLEX=$ac_cv_prog_FLEX
6609 if test -n "$FLEX"; then
6610   echo "$as_me:$LINENO: result: $FLEX" >&5
6611 echo "${ECHO_T}$FLEX" >&6
6612 else
6613   echo "$as_me:$LINENO: result: no" >&5
6614 echo "${ECHO_T}no" >&6
6615 fi
6616
6617   test -n "$FLEX" && break
6618 done
6619 test -n "$FLEX" || FLEX="$MISSING flex"
6620
6621 case " $build_configdirs " in
6622   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6623 esac
6624
6625 for ac_prog in makeinfo
6626 do
6627   # Extract the first word of "$ac_prog", so it can be a program name with args.
6628 set dummy $ac_prog; ac_word=$2
6629 echo "$as_me:$LINENO: checking for $ac_word" >&5
6630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6631 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6632   echo $ECHO_N "(cached) $ECHO_C" >&6
6633 else
6634   if test -n "$MAKEINFO"; then
6635   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6636 else
6637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6638 for as_dir in $PATH
6639 do
6640   IFS=$as_save_IFS
6641   test -z "$as_dir" && as_dir=.
6642   for ac_exec_ext in '' $ac_executable_extensions; do
6643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6644     ac_cv_prog_MAKEINFO="$ac_prog"
6645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6646     break 2
6647   fi
6648 done
6649 done
6650
6651 fi
6652 fi
6653 MAKEINFO=$ac_cv_prog_MAKEINFO
6654 if test -n "$MAKEINFO"; then
6655   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6656 echo "${ECHO_T}$MAKEINFO" >&6
6657 else
6658   echo "$as_me:$LINENO: result: no" >&5
6659 echo "${ECHO_T}no" >&6
6660 fi
6661
6662   test -n "$MAKEINFO" && break
6663 done
6664 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6665
6666 case " $build_configdirs " in
6667   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6668   *)
6669
6670     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6671     # higher, else we use the "missing" dummy.
6672     if ${MAKEINFO} --version \
6673        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6674       :
6675     else
6676       MAKEINFO="$MISSING makeinfo"
6677     fi
6678     ;;
6679
6680 esac
6681
6682 # FIXME: expect and dejagnu may become build tools?
6683
6684 for ac_prog in expect
6685 do
6686   # Extract the first word of "$ac_prog", so it can be a program name with args.
6687 set dummy $ac_prog; ac_word=$2
6688 echo "$as_me:$LINENO: checking for $ac_word" >&5
6689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6690 if test "${ac_cv_prog_EXPECT+set}" = set; then
6691   echo $ECHO_N "(cached) $ECHO_C" >&6
6692 else
6693   if test -n "$EXPECT"; then
6694   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6695 else
6696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6697 for as_dir in $PATH
6698 do
6699   IFS=$as_save_IFS
6700   test -z "$as_dir" && as_dir=.
6701   for ac_exec_ext in '' $ac_executable_extensions; do
6702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6703     ac_cv_prog_EXPECT="$ac_prog"
6704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6705     break 2
6706   fi
6707 done
6708 done
6709
6710 fi
6711 fi
6712 EXPECT=$ac_cv_prog_EXPECT
6713 if test -n "$EXPECT"; then
6714   echo "$as_me:$LINENO: result: $EXPECT" >&5
6715 echo "${ECHO_T}$EXPECT" >&6
6716 else
6717   echo "$as_me:$LINENO: result: no" >&5
6718 echo "${ECHO_T}no" >&6
6719 fi
6720
6721   test -n "$EXPECT" && break
6722 done
6723 test -n "$EXPECT" || EXPECT="expect"
6724
6725 case " $configdirs " in
6726   *" expect "*)
6727     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6728     ;;
6729 esac
6730
6731 for ac_prog in runtest
6732 do
6733   # Extract the first word of "$ac_prog", so it can be a program name with args.
6734 set dummy $ac_prog; ac_word=$2
6735 echo "$as_me:$LINENO: checking for $ac_word" >&5
6736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6737 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6738   echo $ECHO_N "(cached) $ECHO_C" >&6
6739 else
6740   if test -n "$RUNTEST"; then
6741   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6742 else
6743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6744 for as_dir in $PATH
6745 do
6746   IFS=$as_save_IFS
6747   test -z "$as_dir" && as_dir=.
6748   for ac_exec_ext in '' $ac_executable_extensions; do
6749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6750     ac_cv_prog_RUNTEST="$ac_prog"
6751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6752     break 2
6753   fi
6754 done
6755 done
6756
6757 fi
6758 fi
6759 RUNTEST=$ac_cv_prog_RUNTEST
6760 if test -n "$RUNTEST"; then
6761   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6762 echo "${ECHO_T}$RUNTEST" >&6
6763 else
6764   echo "$as_me:$LINENO: result: no" >&5
6765 echo "${ECHO_T}no" >&6
6766 fi
6767
6768   test -n "$RUNTEST" && break
6769 done
6770 test -n "$RUNTEST" || RUNTEST="runtest"
6771
6772 case " $configdirs " in
6773   *" dejagnu "*)
6774     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6775     ;;
6776 esac
6777
6778
6779 # Host tools.
6780 ncn_tool_prefix=
6781 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6782 ncn_target_tool_prefix=
6783 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6784
6785
6786
6787 if test -n "$AR"; then
6788   ac_cv_prog_AR=$AR
6789 elif test -n "$ac_cv_prog_AR"; then
6790   AR=$ac_cv_prog_AR
6791 fi
6792
6793 if test -n "$ac_cv_prog_AR"; then
6794   for ncn_progname in ar; do
6795     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6796 set dummy ${ncn_progname}; ac_word=$2
6797 echo "$as_me:$LINENO: checking for $ac_word" >&5
6798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6799 if test "${ac_cv_prog_AR+set}" = set; then
6800   echo $ECHO_N "(cached) $ECHO_C" >&6
6801 else
6802   if test -n "$AR"; then
6803   ac_cv_prog_AR="$AR" # Let the user override the test.
6804 else
6805 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6806 for as_dir in $PATH
6807 do
6808   IFS=$as_save_IFS
6809   test -z "$as_dir" && as_dir=.
6810   for ac_exec_ext in '' $ac_executable_extensions; do
6811   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6812     ac_cv_prog_AR="${ncn_progname}"
6813     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6814     break 2
6815   fi
6816 done
6817 done
6818
6819 fi
6820 fi
6821 AR=$ac_cv_prog_AR
6822 if test -n "$AR"; then
6823   echo "$as_me:$LINENO: result: $AR" >&5
6824 echo "${ECHO_T}$AR" >&6
6825 else
6826   echo "$as_me:$LINENO: result: no" >&5
6827 echo "${ECHO_T}no" >&6
6828 fi
6829
6830   done
6831 fi
6832
6833 for ncn_progname in ar; do
6834   if test -n "$ncn_tool_prefix"; then
6835     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6836 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6837 echo "$as_me:$LINENO: checking for $ac_word" >&5
6838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6839 if test "${ac_cv_prog_AR+set}" = set; then
6840   echo $ECHO_N "(cached) $ECHO_C" >&6
6841 else
6842   if test -n "$AR"; then
6843   ac_cv_prog_AR="$AR" # Let the user override the test.
6844 else
6845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6846 for as_dir in $PATH
6847 do
6848   IFS=$as_save_IFS
6849   test -z "$as_dir" && as_dir=.
6850   for ac_exec_ext in '' $ac_executable_extensions; do
6851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6852     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6854     break 2
6855   fi
6856 done
6857 done
6858
6859 fi
6860 fi
6861 AR=$ac_cv_prog_AR
6862 if test -n "$AR"; then
6863   echo "$as_me:$LINENO: result: $AR" >&5
6864 echo "${ECHO_T}$AR" >&6
6865 else
6866   echo "$as_me:$LINENO: result: no" >&5
6867 echo "${ECHO_T}no" >&6
6868 fi
6869
6870   fi
6871   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6872     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6873 set dummy ${ncn_progname}; ac_word=$2
6874 echo "$as_me:$LINENO: checking for $ac_word" >&5
6875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6876 if test "${ac_cv_prog_AR+set}" = set; then
6877   echo $ECHO_N "(cached) $ECHO_C" >&6
6878 else
6879   if test -n "$AR"; then
6880   ac_cv_prog_AR="$AR" # Let the user override the test.
6881 else
6882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6883 for as_dir in $PATH
6884 do
6885   IFS=$as_save_IFS
6886   test -z "$as_dir" && as_dir=.
6887   for ac_exec_ext in '' $ac_executable_extensions; do
6888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6889     ac_cv_prog_AR="${ncn_progname}"
6890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6891     break 2
6892   fi
6893 done
6894 done
6895
6896 fi
6897 fi
6898 AR=$ac_cv_prog_AR
6899 if test -n "$AR"; then
6900   echo "$as_me:$LINENO: result: $AR" >&5
6901 echo "${ECHO_T}$AR" >&6
6902 else
6903   echo "$as_me:$LINENO: result: no" >&5
6904 echo "${ECHO_T}no" >&6
6905 fi
6906
6907   fi
6908   test -n "$ac_cv_prog_AR" && break
6909 done
6910
6911 if test -z "$ac_cv_prog_AR" ; then
6912   set dummy ar
6913   if test $build = $host ; then
6914     AR="$2"
6915   else
6916     AR="${ncn_tool_prefix}$2"
6917   fi
6918 fi
6919
6920
6921
6922 if test -n "$AS"; then
6923   ac_cv_prog_AS=$AS
6924 elif test -n "$ac_cv_prog_AS"; then
6925   AS=$ac_cv_prog_AS
6926 fi
6927
6928 if test -n "$ac_cv_prog_AS"; then
6929   for ncn_progname in as; do
6930     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6931 set dummy ${ncn_progname}; ac_word=$2
6932 echo "$as_me:$LINENO: checking for $ac_word" >&5
6933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6934 if test "${ac_cv_prog_AS+set}" = set; then
6935   echo $ECHO_N "(cached) $ECHO_C" >&6
6936 else
6937   if test -n "$AS"; then
6938   ac_cv_prog_AS="$AS" # Let the user override the test.
6939 else
6940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6941 for as_dir in $PATH
6942 do
6943   IFS=$as_save_IFS
6944   test -z "$as_dir" && as_dir=.
6945   for ac_exec_ext in '' $ac_executable_extensions; do
6946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6947     ac_cv_prog_AS="${ncn_progname}"
6948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6949     break 2
6950   fi
6951 done
6952 done
6953
6954 fi
6955 fi
6956 AS=$ac_cv_prog_AS
6957 if test -n "$AS"; then
6958   echo "$as_me:$LINENO: result: $AS" >&5
6959 echo "${ECHO_T}$AS" >&6
6960 else
6961   echo "$as_me:$LINENO: result: no" >&5
6962 echo "${ECHO_T}no" >&6
6963 fi
6964
6965   done
6966 fi
6967
6968 for ncn_progname in as; do
6969   if test -n "$ncn_tool_prefix"; then
6970     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6971 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6972 echo "$as_me:$LINENO: checking for $ac_word" >&5
6973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6974 if test "${ac_cv_prog_AS+set}" = set; then
6975   echo $ECHO_N "(cached) $ECHO_C" >&6
6976 else
6977   if test -n "$AS"; then
6978   ac_cv_prog_AS="$AS" # Let the user override the test.
6979 else
6980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6981 for as_dir in $PATH
6982 do
6983   IFS=$as_save_IFS
6984   test -z "$as_dir" && as_dir=.
6985   for ac_exec_ext in '' $ac_executable_extensions; do
6986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6987     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6989     break 2
6990   fi
6991 done
6992 done
6993
6994 fi
6995 fi
6996 AS=$ac_cv_prog_AS
6997 if test -n "$AS"; then
6998   echo "$as_me:$LINENO: result: $AS" >&5
6999 echo "${ECHO_T}$AS" >&6
7000 else
7001   echo "$as_me:$LINENO: result: no" >&5
7002 echo "${ECHO_T}no" >&6
7003 fi
7004
7005   fi
7006   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7007     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7008 set dummy ${ncn_progname}; ac_word=$2
7009 echo "$as_me:$LINENO: checking for $ac_word" >&5
7010 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7011 if test "${ac_cv_prog_AS+set}" = set; then
7012   echo $ECHO_N "(cached) $ECHO_C" >&6
7013 else
7014   if test -n "$AS"; then
7015   ac_cv_prog_AS="$AS" # Let the user override the test.
7016 else
7017 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7018 for as_dir in $PATH
7019 do
7020   IFS=$as_save_IFS
7021   test -z "$as_dir" && as_dir=.
7022   for ac_exec_ext in '' $ac_executable_extensions; do
7023   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7024     ac_cv_prog_AS="${ncn_progname}"
7025     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7026     break 2
7027   fi
7028 done
7029 done
7030
7031 fi
7032 fi
7033 AS=$ac_cv_prog_AS
7034 if test -n "$AS"; then
7035   echo "$as_me:$LINENO: result: $AS" >&5
7036 echo "${ECHO_T}$AS" >&6
7037 else
7038   echo "$as_me:$LINENO: result: no" >&5
7039 echo "${ECHO_T}no" >&6
7040 fi
7041
7042   fi
7043   test -n "$ac_cv_prog_AS" && break
7044 done
7045
7046 if test -z "$ac_cv_prog_AS" ; then
7047   set dummy as
7048   if test $build = $host ; then
7049     AS="$2"
7050   else
7051     AS="${ncn_tool_prefix}$2"
7052   fi
7053 fi
7054
7055
7056
7057 if test -n "$DLLTOOL"; then
7058   ac_cv_prog_DLLTOOL=$DLLTOOL
7059 elif test -n "$ac_cv_prog_DLLTOOL"; then
7060   DLLTOOL=$ac_cv_prog_DLLTOOL
7061 fi
7062
7063 if test -n "$ac_cv_prog_DLLTOOL"; then
7064   for ncn_progname in dlltool; do
7065     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7066 set dummy ${ncn_progname}; ac_word=$2
7067 echo "$as_me:$LINENO: checking for $ac_word" >&5
7068 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7069 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7070   echo $ECHO_N "(cached) $ECHO_C" >&6
7071 else
7072   if test -n "$DLLTOOL"; then
7073   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7074 else
7075 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7076 for as_dir in $PATH
7077 do
7078   IFS=$as_save_IFS
7079   test -z "$as_dir" && as_dir=.
7080   for ac_exec_ext in '' $ac_executable_extensions; do
7081   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7082     ac_cv_prog_DLLTOOL="${ncn_progname}"
7083     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7084     break 2
7085   fi
7086 done
7087 done
7088
7089 fi
7090 fi
7091 DLLTOOL=$ac_cv_prog_DLLTOOL
7092 if test -n "$DLLTOOL"; then
7093   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7094 echo "${ECHO_T}$DLLTOOL" >&6
7095 else
7096   echo "$as_me:$LINENO: result: no" >&5
7097 echo "${ECHO_T}no" >&6
7098 fi
7099
7100   done
7101 fi
7102
7103 for ncn_progname in dlltool; do
7104   if test -n "$ncn_tool_prefix"; then
7105     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7106 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7107 echo "$as_me:$LINENO: checking for $ac_word" >&5
7108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7109 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7110   echo $ECHO_N "(cached) $ECHO_C" >&6
7111 else
7112   if test -n "$DLLTOOL"; then
7113   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7114 else
7115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7116 for as_dir in $PATH
7117 do
7118   IFS=$as_save_IFS
7119   test -z "$as_dir" && as_dir=.
7120   for ac_exec_ext in '' $ac_executable_extensions; do
7121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7122     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7124     break 2
7125   fi
7126 done
7127 done
7128
7129 fi
7130 fi
7131 DLLTOOL=$ac_cv_prog_DLLTOOL
7132 if test -n "$DLLTOOL"; then
7133   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7134 echo "${ECHO_T}$DLLTOOL" >&6
7135 else
7136   echo "$as_me:$LINENO: result: no" >&5
7137 echo "${ECHO_T}no" >&6
7138 fi
7139
7140   fi
7141   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7142     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7143 set dummy ${ncn_progname}; ac_word=$2
7144 echo "$as_me:$LINENO: checking for $ac_word" >&5
7145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7146 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7147   echo $ECHO_N "(cached) $ECHO_C" >&6
7148 else
7149   if test -n "$DLLTOOL"; then
7150   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7151 else
7152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7153 for as_dir in $PATH
7154 do
7155   IFS=$as_save_IFS
7156   test -z "$as_dir" && as_dir=.
7157   for ac_exec_ext in '' $ac_executable_extensions; do
7158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7159     ac_cv_prog_DLLTOOL="${ncn_progname}"
7160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7161     break 2
7162   fi
7163 done
7164 done
7165
7166 fi
7167 fi
7168 DLLTOOL=$ac_cv_prog_DLLTOOL
7169 if test -n "$DLLTOOL"; then
7170   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7171 echo "${ECHO_T}$DLLTOOL" >&6
7172 else
7173   echo "$as_me:$LINENO: result: no" >&5
7174 echo "${ECHO_T}no" >&6
7175 fi
7176
7177   fi
7178   test -n "$ac_cv_prog_DLLTOOL" && break
7179 done
7180
7181 if test -z "$ac_cv_prog_DLLTOOL" ; then
7182   set dummy dlltool
7183   if test $build = $host ; then
7184     DLLTOOL="$2"
7185   else
7186     DLLTOOL="${ncn_tool_prefix}$2"
7187   fi
7188 fi
7189
7190
7191
7192 if test -n "$LD"; then
7193   ac_cv_prog_LD=$LD
7194 elif test -n "$ac_cv_prog_LD"; then
7195   LD=$ac_cv_prog_LD
7196 fi
7197
7198 if test -n "$ac_cv_prog_LD"; then
7199   for ncn_progname in ld; do
7200     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7201 set dummy ${ncn_progname}; ac_word=$2
7202 echo "$as_me:$LINENO: checking for $ac_word" >&5
7203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7204 if test "${ac_cv_prog_LD+set}" = set; then
7205   echo $ECHO_N "(cached) $ECHO_C" >&6
7206 else
7207   if test -n "$LD"; then
7208   ac_cv_prog_LD="$LD" # Let the user override the test.
7209 else
7210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7211 for as_dir in $PATH
7212 do
7213   IFS=$as_save_IFS
7214   test -z "$as_dir" && as_dir=.
7215   for ac_exec_ext in '' $ac_executable_extensions; do
7216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7217     ac_cv_prog_LD="${ncn_progname}"
7218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7219     break 2
7220   fi
7221 done
7222 done
7223
7224 fi
7225 fi
7226 LD=$ac_cv_prog_LD
7227 if test -n "$LD"; then
7228   echo "$as_me:$LINENO: result: $LD" >&5
7229 echo "${ECHO_T}$LD" >&6
7230 else
7231   echo "$as_me:$LINENO: result: no" >&5
7232 echo "${ECHO_T}no" >&6
7233 fi
7234
7235   done
7236 fi
7237
7238 for ncn_progname in ld; do
7239   if test -n "$ncn_tool_prefix"; then
7240     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7241 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7242 echo "$as_me:$LINENO: checking for $ac_word" >&5
7243 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7244 if test "${ac_cv_prog_LD+set}" = set; then
7245   echo $ECHO_N "(cached) $ECHO_C" >&6
7246 else
7247   if test -n "$LD"; then
7248   ac_cv_prog_LD="$LD" # Let the user override the test.
7249 else
7250 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7251 for as_dir in $PATH
7252 do
7253   IFS=$as_save_IFS
7254   test -z "$as_dir" && as_dir=.
7255   for ac_exec_ext in '' $ac_executable_extensions; do
7256   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7257     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7258     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7259     break 2
7260   fi
7261 done
7262 done
7263
7264 fi
7265 fi
7266 LD=$ac_cv_prog_LD
7267 if test -n "$LD"; then
7268   echo "$as_me:$LINENO: result: $LD" >&5
7269 echo "${ECHO_T}$LD" >&6
7270 else
7271   echo "$as_me:$LINENO: result: no" >&5
7272 echo "${ECHO_T}no" >&6
7273 fi
7274
7275   fi
7276   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7277     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7278 set dummy ${ncn_progname}; ac_word=$2
7279 echo "$as_me:$LINENO: checking for $ac_word" >&5
7280 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7281 if test "${ac_cv_prog_LD+set}" = set; then
7282   echo $ECHO_N "(cached) $ECHO_C" >&6
7283 else
7284   if test -n "$LD"; then
7285   ac_cv_prog_LD="$LD" # Let the user override the test.
7286 else
7287 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7288 for as_dir in $PATH
7289 do
7290   IFS=$as_save_IFS
7291   test -z "$as_dir" && as_dir=.
7292   for ac_exec_ext in '' $ac_executable_extensions; do
7293   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7294     ac_cv_prog_LD="${ncn_progname}"
7295     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7296     break 2
7297   fi
7298 done
7299 done
7300
7301 fi
7302 fi
7303 LD=$ac_cv_prog_LD
7304 if test -n "$LD"; then
7305   echo "$as_me:$LINENO: result: $LD" >&5
7306 echo "${ECHO_T}$LD" >&6
7307 else
7308   echo "$as_me:$LINENO: result: no" >&5
7309 echo "${ECHO_T}no" >&6
7310 fi
7311
7312   fi
7313   test -n "$ac_cv_prog_LD" && break
7314 done
7315
7316 if test -z "$ac_cv_prog_LD" ; then
7317   set dummy ld
7318   if test $build = $host ; then
7319     LD="$2"
7320   else
7321     LD="${ncn_tool_prefix}$2"
7322   fi
7323 fi
7324
7325
7326
7327 if test -n "$LIPO"; then
7328   ac_cv_prog_LIPO=$LIPO
7329 elif test -n "$ac_cv_prog_LIPO"; then
7330   LIPO=$ac_cv_prog_LIPO
7331 fi
7332
7333 if test -n "$ac_cv_prog_LIPO"; then
7334   for ncn_progname in lipo; do
7335     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7336 set dummy ${ncn_progname}; ac_word=$2
7337 echo "$as_me:$LINENO: checking for $ac_word" >&5
7338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7339 if test "${ac_cv_prog_LIPO+set}" = set; then
7340   echo $ECHO_N "(cached) $ECHO_C" >&6
7341 else
7342   if test -n "$LIPO"; then
7343   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7344 else
7345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7346 for as_dir in $PATH
7347 do
7348   IFS=$as_save_IFS
7349   test -z "$as_dir" && as_dir=.
7350   for ac_exec_ext in '' $ac_executable_extensions; do
7351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7352     ac_cv_prog_LIPO="${ncn_progname}"
7353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7354     break 2
7355   fi
7356 done
7357 done
7358
7359 fi
7360 fi
7361 LIPO=$ac_cv_prog_LIPO
7362 if test -n "$LIPO"; then
7363   echo "$as_me:$LINENO: result: $LIPO" >&5
7364 echo "${ECHO_T}$LIPO" >&6
7365 else
7366   echo "$as_me:$LINENO: result: no" >&5
7367 echo "${ECHO_T}no" >&6
7368 fi
7369
7370   done
7371 fi
7372
7373 for ncn_progname in lipo; do
7374   if test -n "$ncn_tool_prefix"; then
7375     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7376 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7377 echo "$as_me:$LINENO: checking for $ac_word" >&5
7378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7379 if test "${ac_cv_prog_LIPO+set}" = set; then
7380   echo $ECHO_N "(cached) $ECHO_C" >&6
7381 else
7382   if test -n "$LIPO"; then
7383   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7384 else
7385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7386 for as_dir in $PATH
7387 do
7388   IFS=$as_save_IFS
7389   test -z "$as_dir" && as_dir=.
7390   for ac_exec_ext in '' $ac_executable_extensions; do
7391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7392     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7394     break 2
7395   fi
7396 done
7397 done
7398
7399 fi
7400 fi
7401 LIPO=$ac_cv_prog_LIPO
7402 if test -n "$LIPO"; then
7403   echo "$as_me:$LINENO: result: $LIPO" >&5
7404 echo "${ECHO_T}$LIPO" >&6
7405 else
7406   echo "$as_me:$LINENO: result: no" >&5
7407 echo "${ECHO_T}no" >&6
7408 fi
7409
7410   fi
7411   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7412     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7413 set dummy ${ncn_progname}; ac_word=$2
7414 echo "$as_me:$LINENO: checking for $ac_word" >&5
7415 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7416 if test "${ac_cv_prog_LIPO+set}" = set; then
7417   echo $ECHO_N "(cached) $ECHO_C" >&6
7418 else
7419   if test -n "$LIPO"; then
7420   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7421 else
7422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7423 for as_dir in $PATH
7424 do
7425   IFS=$as_save_IFS
7426   test -z "$as_dir" && as_dir=.
7427   for ac_exec_ext in '' $ac_executable_extensions; do
7428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7429     ac_cv_prog_LIPO="${ncn_progname}"
7430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7431     break 2
7432   fi
7433 done
7434 done
7435
7436 fi
7437 fi
7438 LIPO=$ac_cv_prog_LIPO
7439 if test -n "$LIPO"; then
7440   echo "$as_me:$LINENO: result: $LIPO" >&5
7441 echo "${ECHO_T}$LIPO" >&6
7442 else
7443   echo "$as_me:$LINENO: result: no" >&5
7444 echo "${ECHO_T}no" >&6
7445 fi
7446
7447   fi
7448   test -n "$ac_cv_prog_LIPO" && break
7449 done
7450
7451 if test -z "$ac_cv_prog_LIPO" ; then
7452   set dummy lipo
7453   if test $build = $host ; then
7454     LIPO="$2"
7455   else
7456     LIPO="${ncn_tool_prefix}$2"
7457   fi
7458 fi
7459
7460
7461
7462 if test -n "$NM"; then
7463   ac_cv_prog_NM=$NM
7464 elif test -n "$ac_cv_prog_NM"; then
7465   NM=$ac_cv_prog_NM
7466 fi
7467
7468 if test -n "$ac_cv_prog_NM"; then
7469   for ncn_progname in nm; do
7470     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7471 set dummy ${ncn_progname}; ac_word=$2
7472 echo "$as_me:$LINENO: checking for $ac_word" >&5
7473 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7474 if test "${ac_cv_prog_NM+set}" = set; then
7475   echo $ECHO_N "(cached) $ECHO_C" >&6
7476 else
7477   if test -n "$NM"; then
7478   ac_cv_prog_NM="$NM" # Let the user override the test.
7479 else
7480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7481 for as_dir in $PATH
7482 do
7483   IFS=$as_save_IFS
7484   test -z "$as_dir" && as_dir=.
7485   for ac_exec_ext in '' $ac_executable_extensions; do
7486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7487     ac_cv_prog_NM="${ncn_progname}"
7488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7489     break 2
7490   fi
7491 done
7492 done
7493
7494 fi
7495 fi
7496 NM=$ac_cv_prog_NM
7497 if test -n "$NM"; then
7498   echo "$as_me:$LINENO: result: $NM" >&5
7499 echo "${ECHO_T}$NM" >&6
7500 else
7501   echo "$as_me:$LINENO: result: no" >&5
7502 echo "${ECHO_T}no" >&6
7503 fi
7504
7505   done
7506 fi
7507
7508 for ncn_progname in nm; do
7509   if test -n "$ncn_tool_prefix"; then
7510     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7511 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7512 echo "$as_me:$LINENO: checking for $ac_word" >&5
7513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7514 if test "${ac_cv_prog_NM+set}" = set; then
7515   echo $ECHO_N "(cached) $ECHO_C" >&6
7516 else
7517   if test -n "$NM"; then
7518   ac_cv_prog_NM="$NM" # Let the user override the test.
7519 else
7520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7521 for as_dir in $PATH
7522 do
7523   IFS=$as_save_IFS
7524   test -z "$as_dir" && as_dir=.
7525   for ac_exec_ext in '' $ac_executable_extensions; do
7526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7527     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7529     break 2
7530   fi
7531 done
7532 done
7533
7534 fi
7535 fi
7536 NM=$ac_cv_prog_NM
7537 if test -n "$NM"; then
7538   echo "$as_me:$LINENO: result: $NM" >&5
7539 echo "${ECHO_T}$NM" >&6
7540 else
7541   echo "$as_me:$LINENO: result: no" >&5
7542 echo "${ECHO_T}no" >&6
7543 fi
7544
7545   fi
7546   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7547     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7548 set dummy ${ncn_progname}; ac_word=$2
7549 echo "$as_me:$LINENO: checking for $ac_word" >&5
7550 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7551 if test "${ac_cv_prog_NM+set}" = set; then
7552   echo $ECHO_N "(cached) $ECHO_C" >&6
7553 else
7554   if test -n "$NM"; then
7555   ac_cv_prog_NM="$NM" # Let the user override the test.
7556 else
7557 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7558 for as_dir in $PATH
7559 do
7560   IFS=$as_save_IFS
7561   test -z "$as_dir" && as_dir=.
7562   for ac_exec_ext in '' $ac_executable_extensions; do
7563   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7564     ac_cv_prog_NM="${ncn_progname}"
7565     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7566     break 2
7567   fi
7568 done
7569 done
7570
7571 fi
7572 fi
7573 NM=$ac_cv_prog_NM
7574 if test -n "$NM"; then
7575   echo "$as_me:$LINENO: result: $NM" >&5
7576 echo "${ECHO_T}$NM" >&6
7577 else
7578   echo "$as_me:$LINENO: result: no" >&5
7579 echo "${ECHO_T}no" >&6
7580 fi
7581
7582   fi
7583   test -n "$ac_cv_prog_NM" && break
7584 done
7585
7586 if test -z "$ac_cv_prog_NM" ; then
7587   set dummy nm
7588   if test $build = $host ; then
7589     NM="$2"
7590   else
7591     NM="${ncn_tool_prefix}$2"
7592   fi
7593 fi
7594
7595
7596
7597 if test -n "$RANLIB"; then
7598   ac_cv_prog_RANLIB=$RANLIB
7599 elif test -n "$ac_cv_prog_RANLIB"; then
7600   RANLIB=$ac_cv_prog_RANLIB
7601 fi
7602
7603 if test -n "$ac_cv_prog_RANLIB"; then
7604   for ncn_progname in ranlib; do
7605     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7606 set dummy ${ncn_progname}; ac_word=$2
7607 echo "$as_me:$LINENO: checking for $ac_word" >&5
7608 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7609 if test "${ac_cv_prog_RANLIB+set}" = set; then
7610   echo $ECHO_N "(cached) $ECHO_C" >&6
7611 else
7612   if test -n "$RANLIB"; then
7613   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7614 else
7615 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7616 for as_dir in $PATH
7617 do
7618   IFS=$as_save_IFS
7619   test -z "$as_dir" && as_dir=.
7620   for ac_exec_ext in '' $ac_executable_extensions; do
7621   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7622     ac_cv_prog_RANLIB="${ncn_progname}"
7623     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7624     break 2
7625   fi
7626 done
7627 done
7628
7629 fi
7630 fi
7631 RANLIB=$ac_cv_prog_RANLIB
7632 if test -n "$RANLIB"; then
7633   echo "$as_me:$LINENO: result: $RANLIB" >&5
7634 echo "${ECHO_T}$RANLIB" >&6
7635 else
7636   echo "$as_me:$LINENO: result: no" >&5
7637 echo "${ECHO_T}no" >&6
7638 fi
7639
7640   done
7641 fi
7642
7643 for ncn_progname in ranlib; do
7644   if test -n "$ncn_tool_prefix"; then
7645     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7646 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7647 echo "$as_me:$LINENO: checking for $ac_word" >&5
7648 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7649 if test "${ac_cv_prog_RANLIB+set}" = set; then
7650   echo $ECHO_N "(cached) $ECHO_C" >&6
7651 else
7652   if test -n "$RANLIB"; then
7653   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7654 else
7655 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7656 for as_dir in $PATH
7657 do
7658   IFS=$as_save_IFS
7659   test -z "$as_dir" && as_dir=.
7660   for ac_exec_ext in '' $ac_executable_extensions; do
7661   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7662     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7663     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7664     break 2
7665   fi
7666 done
7667 done
7668
7669 fi
7670 fi
7671 RANLIB=$ac_cv_prog_RANLIB
7672 if test -n "$RANLIB"; then
7673   echo "$as_me:$LINENO: result: $RANLIB" >&5
7674 echo "${ECHO_T}$RANLIB" >&6
7675 else
7676   echo "$as_me:$LINENO: result: no" >&5
7677 echo "${ECHO_T}no" >&6
7678 fi
7679
7680   fi
7681   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7682     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7683 set dummy ${ncn_progname}; ac_word=$2
7684 echo "$as_me:$LINENO: checking for $ac_word" >&5
7685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7686 if test "${ac_cv_prog_RANLIB+set}" = set; then
7687   echo $ECHO_N "(cached) $ECHO_C" >&6
7688 else
7689   if test -n "$RANLIB"; then
7690   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7691 else
7692 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7693 for as_dir in $PATH
7694 do
7695   IFS=$as_save_IFS
7696   test -z "$as_dir" && as_dir=.
7697   for ac_exec_ext in '' $ac_executable_extensions; do
7698   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7699     ac_cv_prog_RANLIB="${ncn_progname}"
7700     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7701     break 2
7702   fi
7703 done
7704 done
7705
7706 fi
7707 fi
7708 RANLIB=$ac_cv_prog_RANLIB
7709 if test -n "$RANLIB"; then
7710   echo "$as_me:$LINENO: result: $RANLIB" >&5
7711 echo "${ECHO_T}$RANLIB" >&6
7712 else
7713   echo "$as_me:$LINENO: result: no" >&5
7714 echo "${ECHO_T}no" >&6
7715 fi
7716
7717   fi
7718   test -n "$ac_cv_prog_RANLIB" && break
7719 done
7720
7721 if test -z "$ac_cv_prog_RANLIB" ; then
7722   RANLIB="true"
7723 fi
7724
7725
7726
7727 if test -n "$STRIP"; then
7728   ac_cv_prog_STRIP=$STRIP
7729 elif test -n "$ac_cv_prog_STRIP"; then
7730   STRIP=$ac_cv_prog_STRIP
7731 fi
7732
7733 if test -n "$ac_cv_prog_STRIP"; then
7734   for ncn_progname in strip; do
7735     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7736 set dummy ${ncn_progname}; ac_word=$2
7737 echo "$as_me:$LINENO: checking for $ac_word" >&5
7738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7739 if test "${ac_cv_prog_STRIP+set}" = set; then
7740   echo $ECHO_N "(cached) $ECHO_C" >&6
7741 else
7742   if test -n "$STRIP"; then
7743   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7744 else
7745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7746 for as_dir in $PATH
7747 do
7748   IFS=$as_save_IFS
7749   test -z "$as_dir" && as_dir=.
7750   for ac_exec_ext in '' $ac_executable_extensions; do
7751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7752     ac_cv_prog_STRIP="${ncn_progname}"
7753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7754     break 2
7755   fi
7756 done
7757 done
7758
7759 fi
7760 fi
7761 STRIP=$ac_cv_prog_STRIP
7762 if test -n "$STRIP"; then
7763   echo "$as_me:$LINENO: result: $STRIP" >&5
7764 echo "${ECHO_T}$STRIP" >&6
7765 else
7766   echo "$as_me:$LINENO: result: no" >&5
7767 echo "${ECHO_T}no" >&6
7768 fi
7769
7770   done
7771 fi
7772
7773 for ncn_progname in strip; do
7774   if test -n "$ncn_tool_prefix"; then
7775     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7776 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7777 echo "$as_me:$LINENO: checking for $ac_word" >&5
7778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7779 if test "${ac_cv_prog_STRIP+set}" = set; then
7780   echo $ECHO_N "(cached) $ECHO_C" >&6
7781 else
7782   if test -n "$STRIP"; then
7783   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7784 else
7785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7786 for as_dir in $PATH
7787 do
7788   IFS=$as_save_IFS
7789   test -z "$as_dir" && as_dir=.
7790   for ac_exec_ext in '' $ac_executable_extensions; do
7791   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7792     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7793     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7794     break 2
7795   fi
7796 done
7797 done
7798
7799 fi
7800 fi
7801 STRIP=$ac_cv_prog_STRIP
7802 if test -n "$STRIP"; then
7803   echo "$as_me:$LINENO: result: $STRIP" >&5
7804 echo "${ECHO_T}$STRIP" >&6
7805 else
7806   echo "$as_me:$LINENO: result: no" >&5
7807 echo "${ECHO_T}no" >&6
7808 fi
7809
7810   fi
7811   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7812     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7813 set dummy ${ncn_progname}; ac_word=$2
7814 echo "$as_me:$LINENO: checking for $ac_word" >&5
7815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7816 if test "${ac_cv_prog_STRIP+set}" = set; then
7817   echo $ECHO_N "(cached) $ECHO_C" >&6
7818 else
7819   if test -n "$STRIP"; then
7820   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7821 else
7822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7823 for as_dir in $PATH
7824 do
7825   IFS=$as_save_IFS
7826   test -z "$as_dir" && as_dir=.
7827   for ac_exec_ext in '' $ac_executable_extensions; do
7828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7829     ac_cv_prog_STRIP="${ncn_progname}"
7830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7831     break 2
7832   fi
7833 done
7834 done
7835
7836 fi
7837 fi
7838 STRIP=$ac_cv_prog_STRIP
7839 if test -n "$STRIP"; then
7840   echo "$as_me:$LINENO: result: $STRIP" >&5
7841 echo "${ECHO_T}$STRIP" >&6
7842 else
7843   echo "$as_me:$LINENO: result: no" >&5
7844 echo "${ECHO_T}no" >&6
7845 fi
7846
7847   fi
7848   test -n "$ac_cv_prog_STRIP" && break
7849 done
7850
7851 if test -z "$ac_cv_prog_STRIP" ; then
7852   STRIP="true"
7853 fi
7854
7855
7856
7857 if test -n "$WINDRES"; then
7858   ac_cv_prog_WINDRES=$WINDRES
7859 elif test -n "$ac_cv_prog_WINDRES"; then
7860   WINDRES=$ac_cv_prog_WINDRES
7861 fi
7862
7863 if test -n "$ac_cv_prog_WINDRES"; then
7864   for ncn_progname in windres; do
7865     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7866 set dummy ${ncn_progname}; ac_word=$2
7867 echo "$as_me:$LINENO: checking for $ac_word" >&5
7868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7869 if test "${ac_cv_prog_WINDRES+set}" = set; then
7870   echo $ECHO_N "(cached) $ECHO_C" >&6
7871 else
7872   if test -n "$WINDRES"; then
7873   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7874 else
7875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7876 for as_dir in $PATH
7877 do
7878   IFS=$as_save_IFS
7879   test -z "$as_dir" && as_dir=.
7880   for ac_exec_ext in '' $ac_executable_extensions; do
7881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7882     ac_cv_prog_WINDRES="${ncn_progname}"
7883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7884     break 2
7885   fi
7886 done
7887 done
7888
7889 fi
7890 fi
7891 WINDRES=$ac_cv_prog_WINDRES
7892 if test -n "$WINDRES"; then
7893   echo "$as_me:$LINENO: result: $WINDRES" >&5
7894 echo "${ECHO_T}$WINDRES" >&6
7895 else
7896   echo "$as_me:$LINENO: result: no" >&5
7897 echo "${ECHO_T}no" >&6
7898 fi
7899
7900   done
7901 fi
7902
7903 for ncn_progname in windres; do
7904   if test -n "$ncn_tool_prefix"; then
7905     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7906 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7907 echo "$as_me:$LINENO: checking for $ac_word" >&5
7908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7909 if test "${ac_cv_prog_WINDRES+set}" = set; then
7910   echo $ECHO_N "(cached) $ECHO_C" >&6
7911 else
7912   if test -n "$WINDRES"; then
7913   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7914 else
7915 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7916 for as_dir in $PATH
7917 do
7918   IFS=$as_save_IFS
7919   test -z "$as_dir" && as_dir=.
7920   for ac_exec_ext in '' $ac_executable_extensions; do
7921   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7922     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7923     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7924     break 2
7925   fi
7926 done
7927 done
7928
7929 fi
7930 fi
7931 WINDRES=$ac_cv_prog_WINDRES
7932 if test -n "$WINDRES"; then
7933   echo "$as_me:$LINENO: result: $WINDRES" >&5
7934 echo "${ECHO_T}$WINDRES" >&6
7935 else
7936   echo "$as_me:$LINENO: result: no" >&5
7937 echo "${ECHO_T}no" >&6
7938 fi
7939
7940   fi
7941   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7942     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7943 set dummy ${ncn_progname}; ac_word=$2
7944 echo "$as_me:$LINENO: checking for $ac_word" >&5
7945 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7946 if test "${ac_cv_prog_WINDRES+set}" = set; then
7947   echo $ECHO_N "(cached) $ECHO_C" >&6
7948 else
7949   if test -n "$WINDRES"; then
7950   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7951 else
7952 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7953 for as_dir in $PATH
7954 do
7955   IFS=$as_save_IFS
7956   test -z "$as_dir" && as_dir=.
7957   for ac_exec_ext in '' $ac_executable_extensions; do
7958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7959     ac_cv_prog_WINDRES="${ncn_progname}"
7960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7961     break 2
7962   fi
7963 done
7964 done
7965
7966 fi
7967 fi
7968 WINDRES=$ac_cv_prog_WINDRES
7969 if test -n "$WINDRES"; then
7970   echo "$as_me:$LINENO: result: $WINDRES" >&5
7971 echo "${ECHO_T}$WINDRES" >&6
7972 else
7973   echo "$as_me:$LINENO: result: no" >&5
7974 echo "${ECHO_T}no" >&6
7975 fi
7976
7977   fi
7978   test -n "$ac_cv_prog_WINDRES" && break
7979 done
7980
7981 if test -z "$ac_cv_prog_WINDRES" ; then
7982   set dummy windres
7983   if test $build = $host ; then
7984     WINDRES="$2"
7985   else
7986     WINDRES="${ncn_tool_prefix}$2"
7987   fi
7988 fi
7989
7990
7991
7992 if test -n "$WINDMC"; then
7993   ac_cv_prog_WINDMC=$WINDMC
7994 elif test -n "$ac_cv_prog_WINDMC"; then
7995   WINDMC=$ac_cv_prog_WINDMC
7996 fi
7997
7998 if test -n "$ac_cv_prog_WINDMC"; then
7999   for ncn_progname in windmc; do
8000     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8001 set dummy ${ncn_progname}; ac_word=$2
8002 echo "$as_me:$LINENO: checking for $ac_word" >&5
8003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8004 if test "${ac_cv_prog_WINDMC+set}" = set; then
8005   echo $ECHO_N "(cached) $ECHO_C" >&6
8006 else
8007   if test -n "$WINDMC"; then
8008   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8009 else
8010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8011 for as_dir in $PATH
8012 do
8013   IFS=$as_save_IFS
8014   test -z "$as_dir" && as_dir=.
8015   for ac_exec_ext in '' $ac_executable_extensions; do
8016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8017     ac_cv_prog_WINDMC="${ncn_progname}"
8018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8019     break 2
8020   fi
8021 done
8022 done
8023
8024 fi
8025 fi
8026 WINDMC=$ac_cv_prog_WINDMC
8027 if test -n "$WINDMC"; then
8028   echo "$as_me:$LINENO: result: $WINDMC" >&5
8029 echo "${ECHO_T}$WINDMC" >&6
8030 else
8031   echo "$as_me:$LINENO: result: no" >&5
8032 echo "${ECHO_T}no" >&6
8033 fi
8034
8035   done
8036 fi
8037
8038 for ncn_progname in windmc; do
8039   if test -n "$ncn_tool_prefix"; then
8040     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8041 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8042 echo "$as_me:$LINENO: checking for $ac_word" >&5
8043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8044 if test "${ac_cv_prog_WINDMC+set}" = set; then
8045   echo $ECHO_N "(cached) $ECHO_C" >&6
8046 else
8047   if test -n "$WINDMC"; then
8048   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8049 else
8050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8051 for as_dir in $PATH
8052 do
8053   IFS=$as_save_IFS
8054   test -z "$as_dir" && as_dir=.
8055   for ac_exec_ext in '' $ac_executable_extensions; do
8056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8057     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8059     break 2
8060   fi
8061 done
8062 done
8063
8064 fi
8065 fi
8066 WINDMC=$ac_cv_prog_WINDMC
8067 if test -n "$WINDMC"; then
8068   echo "$as_me:$LINENO: result: $WINDMC" >&5
8069 echo "${ECHO_T}$WINDMC" >&6
8070 else
8071   echo "$as_me:$LINENO: result: no" >&5
8072 echo "${ECHO_T}no" >&6
8073 fi
8074
8075   fi
8076   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8077     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8078 set dummy ${ncn_progname}; ac_word=$2
8079 echo "$as_me:$LINENO: checking for $ac_word" >&5
8080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8081 if test "${ac_cv_prog_WINDMC+set}" = set; then
8082   echo $ECHO_N "(cached) $ECHO_C" >&6
8083 else
8084   if test -n "$WINDMC"; then
8085   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8086 else
8087 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8088 for as_dir in $PATH
8089 do
8090   IFS=$as_save_IFS
8091   test -z "$as_dir" && as_dir=.
8092   for ac_exec_ext in '' $ac_executable_extensions; do
8093   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8094     ac_cv_prog_WINDMC="${ncn_progname}"
8095     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8096     break 2
8097   fi
8098 done
8099 done
8100
8101 fi
8102 fi
8103 WINDMC=$ac_cv_prog_WINDMC
8104 if test -n "$WINDMC"; then
8105   echo "$as_me:$LINENO: result: $WINDMC" >&5
8106 echo "${ECHO_T}$WINDMC" >&6
8107 else
8108   echo "$as_me:$LINENO: result: no" >&5
8109 echo "${ECHO_T}no" >&6
8110 fi
8111
8112   fi
8113   test -n "$ac_cv_prog_WINDMC" && break
8114 done
8115
8116 if test -z "$ac_cv_prog_WINDMC" ; then
8117   set dummy windmc
8118   if test $build = $host ; then
8119     WINDMC="$2"
8120   else
8121     WINDMC="${ncn_tool_prefix}$2"
8122   fi
8123 fi
8124
8125
8126
8127 if test -n "$OBJCOPY"; then
8128   ac_cv_prog_OBJCOPY=$OBJCOPY
8129 elif test -n "$ac_cv_prog_OBJCOPY"; then
8130   OBJCOPY=$ac_cv_prog_OBJCOPY
8131 fi
8132
8133 if test -n "$ac_cv_prog_OBJCOPY"; then
8134   for ncn_progname in objcopy; do
8135     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8136 set dummy ${ncn_progname}; ac_word=$2
8137 echo "$as_me:$LINENO: checking for $ac_word" >&5
8138 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8139 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8140   echo $ECHO_N "(cached) $ECHO_C" >&6
8141 else
8142   if test -n "$OBJCOPY"; then
8143   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8144 else
8145 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8146 for as_dir in $PATH
8147 do
8148   IFS=$as_save_IFS
8149   test -z "$as_dir" && as_dir=.
8150   for ac_exec_ext in '' $ac_executable_extensions; do
8151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8152     ac_cv_prog_OBJCOPY="${ncn_progname}"
8153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8154     break 2
8155   fi
8156 done
8157 done
8158
8159 fi
8160 fi
8161 OBJCOPY=$ac_cv_prog_OBJCOPY
8162 if test -n "$OBJCOPY"; then
8163   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8164 echo "${ECHO_T}$OBJCOPY" >&6
8165 else
8166   echo "$as_me:$LINENO: result: no" >&5
8167 echo "${ECHO_T}no" >&6
8168 fi
8169
8170   done
8171 fi
8172
8173 for ncn_progname in objcopy; do
8174   if test -n "$ncn_tool_prefix"; then
8175     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8176 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8177 echo "$as_me:$LINENO: checking for $ac_word" >&5
8178 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8179 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8180   echo $ECHO_N "(cached) $ECHO_C" >&6
8181 else
8182   if test -n "$OBJCOPY"; then
8183   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8184 else
8185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8186 for as_dir in $PATH
8187 do
8188   IFS=$as_save_IFS
8189   test -z "$as_dir" && as_dir=.
8190   for ac_exec_ext in '' $ac_executable_extensions; do
8191   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8192     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8193     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8194     break 2
8195   fi
8196 done
8197 done
8198
8199 fi
8200 fi
8201 OBJCOPY=$ac_cv_prog_OBJCOPY
8202 if test -n "$OBJCOPY"; then
8203   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8204 echo "${ECHO_T}$OBJCOPY" >&6
8205 else
8206   echo "$as_me:$LINENO: result: no" >&5
8207 echo "${ECHO_T}no" >&6
8208 fi
8209
8210   fi
8211   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8212     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8213 set dummy ${ncn_progname}; ac_word=$2
8214 echo "$as_me:$LINENO: checking for $ac_word" >&5
8215 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8216 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8217   echo $ECHO_N "(cached) $ECHO_C" >&6
8218 else
8219   if test -n "$OBJCOPY"; then
8220   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8221 else
8222 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8223 for as_dir in $PATH
8224 do
8225   IFS=$as_save_IFS
8226   test -z "$as_dir" && as_dir=.
8227   for ac_exec_ext in '' $ac_executable_extensions; do
8228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8229     ac_cv_prog_OBJCOPY="${ncn_progname}"
8230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8231     break 2
8232   fi
8233 done
8234 done
8235
8236 fi
8237 fi
8238 OBJCOPY=$ac_cv_prog_OBJCOPY
8239 if test -n "$OBJCOPY"; then
8240   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8241 echo "${ECHO_T}$OBJCOPY" >&6
8242 else
8243   echo "$as_me:$LINENO: result: no" >&5
8244 echo "${ECHO_T}no" >&6
8245 fi
8246
8247   fi
8248   test -n "$ac_cv_prog_OBJCOPY" && break
8249 done
8250
8251 if test -z "$ac_cv_prog_OBJCOPY" ; then
8252   set dummy objcopy
8253   if test $build = $host ; then
8254     OBJCOPY="$2"
8255   else
8256     OBJCOPY="${ncn_tool_prefix}$2"
8257   fi
8258 fi
8259
8260
8261
8262 if test -n "$OBJDUMP"; then
8263   ac_cv_prog_OBJDUMP=$OBJDUMP
8264 elif test -n "$ac_cv_prog_OBJDUMP"; then
8265   OBJDUMP=$ac_cv_prog_OBJDUMP
8266 fi
8267
8268 if test -n "$ac_cv_prog_OBJDUMP"; then
8269   for ncn_progname in objdump; do
8270     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8271 set dummy ${ncn_progname}; ac_word=$2
8272 echo "$as_me:$LINENO: checking for $ac_word" >&5
8273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8274 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8275   echo $ECHO_N "(cached) $ECHO_C" >&6
8276 else
8277   if test -n "$OBJDUMP"; then
8278   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8279 else
8280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8281 for as_dir in $PATH
8282 do
8283   IFS=$as_save_IFS
8284   test -z "$as_dir" && as_dir=.
8285   for ac_exec_ext in '' $ac_executable_extensions; do
8286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8287     ac_cv_prog_OBJDUMP="${ncn_progname}"
8288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8289     break 2
8290   fi
8291 done
8292 done
8293
8294 fi
8295 fi
8296 OBJDUMP=$ac_cv_prog_OBJDUMP
8297 if test -n "$OBJDUMP"; then
8298   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8299 echo "${ECHO_T}$OBJDUMP" >&6
8300 else
8301   echo "$as_me:$LINENO: result: no" >&5
8302 echo "${ECHO_T}no" >&6
8303 fi
8304
8305   done
8306 fi
8307
8308 for ncn_progname in objdump; do
8309   if test -n "$ncn_tool_prefix"; then
8310     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8311 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8312 echo "$as_me:$LINENO: checking for $ac_word" >&5
8313 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8314 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8315   echo $ECHO_N "(cached) $ECHO_C" >&6
8316 else
8317   if test -n "$OBJDUMP"; then
8318   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8319 else
8320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8321 for as_dir in $PATH
8322 do
8323   IFS=$as_save_IFS
8324   test -z "$as_dir" && as_dir=.
8325   for ac_exec_ext in '' $ac_executable_extensions; do
8326   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8327     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8328     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8329     break 2
8330   fi
8331 done
8332 done
8333
8334 fi
8335 fi
8336 OBJDUMP=$ac_cv_prog_OBJDUMP
8337 if test -n "$OBJDUMP"; then
8338   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8339 echo "${ECHO_T}$OBJDUMP" >&6
8340 else
8341   echo "$as_me:$LINENO: result: no" >&5
8342 echo "${ECHO_T}no" >&6
8343 fi
8344
8345   fi
8346   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8347     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8348 set dummy ${ncn_progname}; ac_word=$2
8349 echo "$as_me:$LINENO: checking for $ac_word" >&5
8350 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8351 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8352   echo $ECHO_N "(cached) $ECHO_C" >&6
8353 else
8354   if test -n "$OBJDUMP"; then
8355   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8356 else
8357 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8358 for as_dir in $PATH
8359 do
8360   IFS=$as_save_IFS
8361   test -z "$as_dir" && as_dir=.
8362   for ac_exec_ext in '' $ac_executable_extensions; do
8363   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8364     ac_cv_prog_OBJDUMP="${ncn_progname}"
8365     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8366     break 2
8367   fi
8368 done
8369 done
8370
8371 fi
8372 fi
8373 OBJDUMP=$ac_cv_prog_OBJDUMP
8374 if test -n "$OBJDUMP"; then
8375   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8376 echo "${ECHO_T}$OBJDUMP" >&6
8377 else
8378   echo "$as_me:$LINENO: result: no" >&5
8379 echo "${ECHO_T}no" >&6
8380 fi
8381
8382   fi
8383   test -n "$ac_cv_prog_OBJDUMP" && break
8384 done
8385
8386 if test -z "$ac_cv_prog_OBJDUMP" ; then
8387   set dummy objdump
8388   if test $build = $host ; then
8389     OBJDUMP="$2"
8390   else
8391     OBJDUMP="${ncn_tool_prefix}$2"
8392   fi
8393 fi
8394
8395
8396
8397
8398
8399
8400 # Target tools.
8401
8402 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8403 if test "${with_build_time_tools+set}" = set; then
8404   withval="$with_build_time_tools"
8405   case x"$withval" in
8406      x/*) ;;
8407      *)
8408        with_build_time_tools=
8409        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8410 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8411        ;;
8412    esac
8413 else
8414   with_build_time_tools=
8415 fi;
8416
8417
8418
8419 if test -n "$CC_FOR_TARGET"; then
8420   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8421 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8422   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8423 fi
8424
8425 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8426   for ncn_progname in cc gcc; do
8427     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8428 set dummy ${ncn_progname}; ac_word=$2
8429 echo "$as_me:$LINENO: checking for $ac_word" >&5
8430 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8431 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8432   echo $ECHO_N "(cached) $ECHO_C" >&6
8433 else
8434   if test -n "$CC_FOR_TARGET"; then
8435   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8436 else
8437 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8438 for as_dir in $PATH
8439 do
8440   IFS=$as_save_IFS
8441   test -z "$as_dir" && as_dir=.
8442   for ac_exec_ext in '' $ac_executable_extensions; do
8443   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8444     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8445     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8446     break 2
8447   fi
8448 done
8449 done
8450
8451 fi
8452 fi
8453 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8454 if test -n "$CC_FOR_TARGET"; then
8455   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8456 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8457 else
8458   echo "$as_me:$LINENO: result: no" >&5
8459 echo "${ECHO_T}no" >&6
8460 fi
8461
8462   done
8463 fi
8464
8465 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8466   for ncn_progname in cc gcc; do
8467     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8468 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8469     if test -x $with_build_time_tools/${ncn_progname}; then
8470       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8471       echo "$as_me:$LINENO: result: yes" >&5
8472 echo "${ECHO_T}yes" >&6
8473       break
8474     else
8475       echo "$as_me:$LINENO: result: no" >&5
8476 echo "${ECHO_T}no" >&6
8477     fi
8478   done
8479 fi
8480
8481 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8482   for ncn_progname in cc gcc; do
8483     if test -n "$ncn_target_tool_prefix"; then
8484       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8485 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8486 echo "$as_me:$LINENO: checking for $ac_word" >&5
8487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8488 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8489   echo $ECHO_N "(cached) $ECHO_C" >&6
8490 else
8491   if test -n "$CC_FOR_TARGET"; then
8492   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8493 else
8494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8495 for as_dir in $PATH
8496 do
8497   IFS=$as_save_IFS
8498   test -z "$as_dir" && as_dir=.
8499   for ac_exec_ext in '' $ac_executable_extensions; do
8500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8501     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8503     break 2
8504   fi
8505 done
8506 done
8507
8508 fi
8509 fi
8510 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8511 if test -n "$CC_FOR_TARGET"; then
8512   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8513 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8514 else
8515   echo "$as_me:$LINENO: result: no" >&5
8516 echo "${ECHO_T}no" >&6
8517 fi
8518
8519     fi
8520     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8521       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8522 set dummy ${ncn_progname}; ac_word=$2
8523 echo "$as_me:$LINENO: checking for $ac_word" >&5
8524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8525 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8526   echo $ECHO_N "(cached) $ECHO_C" >&6
8527 else
8528   if test -n "$CC_FOR_TARGET"; then
8529   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8530 else
8531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8532 for as_dir in $PATH
8533 do
8534   IFS=$as_save_IFS
8535   test -z "$as_dir" && as_dir=.
8536   for ac_exec_ext in '' $ac_executable_extensions; do
8537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8538     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8540     break 2
8541   fi
8542 done
8543 done
8544
8545 fi
8546 fi
8547 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8548 if test -n "$CC_FOR_TARGET"; then
8549   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8550 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8551 else
8552   echo "$as_me:$LINENO: result: no" >&5
8553 echo "${ECHO_T}no" >&6
8554 fi
8555
8556     fi
8557     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8558   done
8559 fi
8560
8561 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8562   set dummy cc gcc
8563   if test $build = $target ; then
8564     CC_FOR_TARGET="$2"
8565   else
8566     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8567   fi
8568 else
8569   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8570 fi
8571
8572
8573
8574 if test -n "$CXX_FOR_TARGET"; then
8575   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8576 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8577   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8578 fi
8579
8580 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8581   for ncn_progname in c++ g++ cxx gxx; do
8582     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8583 set dummy ${ncn_progname}; ac_word=$2
8584 echo "$as_me:$LINENO: checking for $ac_word" >&5
8585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8586 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8587   echo $ECHO_N "(cached) $ECHO_C" >&6
8588 else
8589   if test -n "$CXX_FOR_TARGET"; then
8590   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8591 else
8592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8593 for as_dir in $PATH
8594 do
8595   IFS=$as_save_IFS
8596   test -z "$as_dir" && as_dir=.
8597   for ac_exec_ext in '' $ac_executable_extensions; do
8598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8599     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8601     break 2
8602   fi
8603 done
8604 done
8605
8606 fi
8607 fi
8608 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8609 if test -n "$CXX_FOR_TARGET"; then
8610   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8611 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8612 else
8613   echo "$as_me:$LINENO: result: no" >&5
8614 echo "${ECHO_T}no" >&6
8615 fi
8616
8617   done
8618 fi
8619
8620 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8621   for ncn_progname in c++ g++ cxx gxx; do
8622     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8623 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8624     if test -x $with_build_time_tools/${ncn_progname}; then
8625       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8626       echo "$as_me:$LINENO: result: yes" >&5
8627 echo "${ECHO_T}yes" >&6
8628       break
8629     else
8630       echo "$as_me:$LINENO: result: no" >&5
8631 echo "${ECHO_T}no" >&6
8632     fi
8633   done
8634 fi
8635
8636 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8637   for ncn_progname in c++ g++ cxx gxx; do
8638     if test -n "$ncn_target_tool_prefix"; then
8639       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8640 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8641 echo "$as_me:$LINENO: checking for $ac_word" >&5
8642 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8643 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8644   echo $ECHO_N "(cached) $ECHO_C" >&6
8645 else
8646   if test -n "$CXX_FOR_TARGET"; then
8647   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8648 else
8649 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8650 for as_dir in $PATH
8651 do
8652   IFS=$as_save_IFS
8653   test -z "$as_dir" && as_dir=.
8654   for ac_exec_ext in '' $ac_executable_extensions; do
8655   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8656     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8657     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8658     break 2
8659   fi
8660 done
8661 done
8662
8663 fi
8664 fi
8665 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8666 if test -n "$CXX_FOR_TARGET"; then
8667   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8668 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8669 else
8670   echo "$as_me:$LINENO: result: no" >&5
8671 echo "${ECHO_T}no" >&6
8672 fi
8673
8674     fi
8675     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8676       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8677 set dummy ${ncn_progname}; ac_word=$2
8678 echo "$as_me:$LINENO: checking for $ac_word" >&5
8679 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8680 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8681   echo $ECHO_N "(cached) $ECHO_C" >&6
8682 else
8683   if test -n "$CXX_FOR_TARGET"; then
8684   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8685 else
8686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8687 for as_dir in $PATH
8688 do
8689   IFS=$as_save_IFS
8690   test -z "$as_dir" && as_dir=.
8691   for ac_exec_ext in '' $ac_executable_extensions; do
8692   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8693     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8694     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8695     break 2
8696   fi
8697 done
8698 done
8699
8700 fi
8701 fi
8702 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8703 if test -n "$CXX_FOR_TARGET"; then
8704   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8705 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8706 else
8707   echo "$as_me:$LINENO: result: no" >&5
8708 echo "${ECHO_T}no" >&6
8709 fi
8710
8711     fi
8712     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8713   done
8714 fi
8715
8716 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8717   set dummy c++ g++ cxx gxx
8718   if test $build = $target ; then
8719     CXX_FOR_TARGET="$2"
8720   else
8721     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8722   fi
8723 else
8724   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8725 fi
8726
8727
8728
8729 if test -n "$GCC_FOR_TARGET"; then
8730   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8731 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8732   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8733 fi
8734
8735 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8736   for ncn_progname in gcc; do
8737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8738 set dummy ${ncn_progname}; ac_word=$2
8739 echo "$as_me:$LINENO: checking for $ac_word" >&5
8740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8741 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8742   echo $ECHO_N "(cached) $ECHO_C" >&6
8743 else
8744   if test -n "$GCC_FOR_TARGET"; then
8745   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8746 else
8747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8748 for as_dir in $PATH
8749 do
8750   IFS=$as_save_IFS
8751   test -z "$as_dir" && as_dir=.
8752   for ac_exec_ext in '' $ac_executable_extensions; do
8753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8754     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8756     break 2
8757   fi
8758 done
8759 done
8760
8761 fi
8762 fi
8763 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8764 if test -n "$GCC_FOR_TARGET"; then
8765   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8766 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8767 else
8768   echo "$as_me:$LINENO: result: no" >&5
8769 echo "${ECHO_T}no" >&6
8770 fi
8771
8772   done
8773 fi
8774
8775 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8776   for ncn_progname in gcc; do
8777     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8778 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8779     if test -x $with_build_time_tools/${ncn_progname}; then
8780       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8781       echo "$as_me:$LINENO: result: yes" >&5
8782 echo "${ECHO_T}yes" >&6
8783       break
8784     else
8785       echo "$as_me:$LINENO: result: no" >&5
8786 echo "${ECHO_T}no" >&6
8787     fi
8788   done
8789 fi
8790
8791 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8792   for ncn_progname in gcc; do
8793     if test -n "$ncn_target_tool_prefix"; then
8794       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8795 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8796 echo "$as_me:$LINENO: checking for $ac_word" >&5
8797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8798 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8799   echo $ECHO_N "(cached) $ECHO_C" >&6
8800 else
8801   if test -n "$GCC_FOR_TARGET"; then
8802   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8803 else
8804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8805 for as_dir in $PATH
8806 do
8807   IFS=$as_save_IFS
8808   test -z "$as_dir" && as_dir=.
8809   for ac_exec_ext in '' $ac_executable_extensions; do
8810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8811     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8813     break 2
8814   fi
8815 done
8816 done
8817
8818 fi
8819 fi
8820 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8821 if test -n "$GCC_FOR_TARGET"; then
8822   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8823 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8824 else
8825   echo "$as_me:$LINENO: result: no" >&5
8826 echo "${ECHO_T}no" >&6
8827 fi
8828
8829     fi
8830     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8831       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8832 set dummy ${ncn_progname}; ac_word=$2
8833 echo "$as_me:$LINENO: checking for $ac_word" >&5
8834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8835 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8836   echo $ECHO_N "(cached) $ECHO_C" >&6
8837 else
8838   if test -n "$GCC_FOR_TARGET"; then
8839   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8840 else
8841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8842 for as_dir in $PATH
8843 do
8844   IFS=$as_save_IFS
8845   test -z "$as_dir" && as_dir=.
8846   for ac_exec_ext in '' $ac_executable_extensions; do
8847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8848     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8850     break 2
8851   fi
8852 done
8853 done
8854
8855 fi
8856 fi
8857 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8858 if test -n "$GCC_FOR_TARGET"; then
8859   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8860 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8861 else
8862   echo "$as_me:$LINENO: result: no" >&5
8863 echo "${ECHO_T}no" >&6
8864 fi
8865
8866     fi
8867     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8868   done
8869 fi
8870
8871 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8872   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8873 else
8874   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8875 fi
8876
8877
8878
8879 if test -n "$GCJ_FOR_TARGET"; then
8880   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8881 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8882   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8883 fi
8884
8885 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8886   for ncn_progname in gcj; do
8887     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8888 set dummy ${ncn_progname}; ac_word=$2
8889 echo "$as_me:$LINENO: checking for $ac_word" >&5
8890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8891 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8892   echo $ECHO_N "(cached) $ECHO_C" >&6
8893 else
8894   if test -n "$GCJ_FOR_TARGET"; then
8895   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8896 else
8897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8898 for as_dir in $PATH
8899 do
8900   IFS=$as_save_IFS
8901   test -z "$as_dir" && as_dir=.
8902   for ac_exec_ext in '' $ac_executable_extensions; do
8903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8904     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8906     break 2
8907   fi
8908 done
8909 done
8910
8911 fi
8912 fi
8913 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8914 if test -n "$GCJ_FOR_TARGET"; then
8915   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8916 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8917 else
8918   echo "$as_me:$LINENO: result: no" >&5
8919 echo "${ECHO_T}no" >&6
8920 fi
8921
8922   done
8923 fi
8924
8925 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8926   for ncn_progname in gcj; do
8927     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8928 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8929     if test -x $with_build_time_tools/${ncn_progname}; then
8930       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8931       echo "$as_me:$LINENO: result: yes" >&5
8932 echo "${ECHO_T}yes" >&6
8933       break
8934     else
8935       echo "$as_me:$LINENO: result: no" >&5
8936 echo "${ECHO_T}no" >&6
8937     fi
8938   done
8939 fi
8940
8941 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8942   for ncn_progname in gcj; do
8943     if test -n "$ncn_target_tool_prefix"; then
8944       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8945 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8946 echo "$as_me:$LINENO: checking for $ac_word" >&5
8947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8948 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8949   echo $ECHO_N "(cached) $ECHO_C" >&6
8950 else
8951   if test -n "$GCJ_FOR_TARGET"; then
8952   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8953 else
8954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8955 for as_dir in $PATH
8956 do
8957   IFS=$as_save_IFS
8958   test -z "$as_dir" && as_dir=.
8959   for ac_exec_ext in '' $ac_executable_extensions; do
8960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8961     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8963     break 2
8964   fi
8965 done
8966 done
8967
8968 fi
8969 fi
8970 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8971 if test -n "$GCJ_FOR_TARGET"; then
8972   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8973 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8974 else
8975   echo "$as_me:$LINENO: result: no" >&5
8976 echo "${ECHO_T}no" >&6
8977 fi
8978
8979     fi
8980     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8981       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8982 set dummy ${ncn_progname}; ac_word=$2
8983 echo "$as_me:$LINENO: checking for $ac_word" >&5
8984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8985 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8986   echo $ECHO_N "(cached) $ECHO_C" >&6
8987 else
8988   if test -n "$GCJ_FOR_TARGET"; then
8989   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8990 else
8991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8992 for as_dir in $PATH
8993 do
8994   IFS=$as_save_IFS
8995   test -z "$as_dir" && as_dir=.
8996   for ac_exec_ext in '' $ac_executable_extensions; do
8997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8998     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9000     break 2
9001   fi
9002 done
9003 done
9004
9005 fi
9006 fi
9007 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9008 if test -n "$GCJ_FOR_TARGET"; then
9009   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9010 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9011 else
9012   echo "$as_me:$LINENO: result: no" >&5
9013 echo "${ECHO_T}no" >&6
9014 fi
9015
9016     fi
9017     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9018   done
9019 fi
9020
9021 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9022   set dummy gcj
9023   if test $build = $target ; then
9024     GCJ_FOR_TARGET="$2"
9025   else
9026     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9027   fi
9028 else
9029   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9030 fi
9031
9032
9033
9034 if test -n "$GFORTRAN_FOR_TARGET"; then
9035   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9036 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9037   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9038 fi
9039
9040 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9041   for ncn_progname in gfortran; do
9042     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9043 set dummy ${ncn_progname}; ac_word=$2
9044 echo "$as_me:$LINENO: checking for $ac_word" >&5
9045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9046 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9047   echo $ECHO_N "(cached) $ECHO_C" >&6
9048 else
9049   if test -n "$GFORTRAN_FOR_TARGET"; then
9050   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9051 else
9052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9053 for as_dir in $PATH
9054 do
9055   IFS=$as_save_IFS
9056   test -z "$as_dir" && as_dir=.
9057   for ac_exec_ext in '' $ac_executable_extensions; do
9058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9059     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9061     break 2
9062   fi
9063 done
9064 done
9065
9066 fi
9067 fi
9068 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9069 if test -n "$GFORTRAN_FOR_TARGET"; then
9070   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9071 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9072 else
9073   echo "$as_me:$LINENO: result: no" >&5
9074 echo "${ECHO_T}no" >&6
9075 fi
9076
9077   done
9078 fi
9079
9080 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9081   for ncn_progname in gfortran; do
9082     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9083 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9084     if test -x $with_build_time_tools/${ncn_progname}; then
9085       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9086       echo "$as_me:$LINENO: result: yes" >&5
9087 echo "${ECHO_T}yes" >&6
9088       break
9089     else
9090       echo "$as_me:$LINENO: result: no" >&5
9091 echo "${ECHO_T}no" >&6
9092     fi
9093   done
9094 fi
9095
9096 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9097   for ncn_progname in gfortran; do
9098     if test -n "$ncn_target_tool_prefix"; then
9099       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9100 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9101 echo "$as_me:$LINENO: checking for $ac_word" >&5
9102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9103 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9104   echo $ECHO_N "(cached) $ECHO_C" >&6
9105 else
9106   if test -n "$GFORTRAN_FOR_TARGET"; then
9107   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9108 else
9109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9110 for as_dir in $PATH
9111 do
9112   IFS=$as_save_IFS
9113   test -z "$as_dir" && as_dir=.
9114   for ac_exec_ext in '' $ac_executable_extensions; do
9115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9116     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9118     break 2
9119   fi
9120 done
9121 done
9122
9123 fi
9124 fi
9125 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9126 if test -n "$GFORTRAN_FOR_TARGET"; then
9127   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9128 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9129 else
9130   echo "$as_me:$LINENO: result: no" >&5
9131 echo "${ECHO_T}no" >&6
9132 fi
9133
9134     fi
9135     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9136       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9137 set dummy ${ncn_progname}; ac_word=$2
9138 echo "$as_me:$LINENO: checking for $ac_word" >&5
9139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9140 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9141   echo $ECHO_N "(cached) $ECHO_C" >&6
9142 else
9143   if test -n "$GFORTRAN_FOR_TARGET"; then
9144   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9145 else
9146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9147 for as_dir in $PATH
9148 do
9149   IFS=$as_save_IFS
9150   test -z "$as_dir" && as_dir=.
9151   for ac_exec_ext in '' $ac_executable_extensions; do
9152   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9153     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9154     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9155     break 2
9156   fi
9157 done
9158 done
9159
9160 fi
9161 fi
9162 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9163 if test -n "$GFORTRAN_FOR_TARGET"; then
9164   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9165 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9166 else
9167   echo "$as_me:$LINENO: result: no" >&5
9168 echo "${ECHO_T}no" >&6
9169 fi
9170
9171     fi
9172     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9173   done
9174 fi
9175
9176 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9177   set dummy gfortran
9178   if test $build = $target ; then
9179     GFORTRAN_FOR_TARGET="$2"
9180   else
9181     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9182   fi
9183 else
9184   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9185 fi
9186
9187
9188
9189 cat > conftest.c << \EOF
9190 #ifdef __GNUC__
9191   gcc_yay;
9192 #endif
9193 EOF
9194 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9195   have_gcc_for_target=yes
9196 else
9197   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9198   have_gcc_for_target=no
9199 fi
9200 rm conftest.c
9201
9202
9203
9204
9205 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9206   if test -n "$with_build_time_tools"; then
9207     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9208 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9209     if test -x $with_build_time_tools/ar; then
9210       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9211       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9212       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9213 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9214     else
9215       echo "$as_me:$LINENO: result: no" >&5
9216 echo "${ECHO_T}no" >&6
9217     fi
9218   elif test $build != $host && test $have_gcc_for_target = yes; then
9219     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9220     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9221     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9222   fi
9223 fi
9224 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9225   # Extract the first word of "ar", so it can be a program name with args.
9226 set dummy ar; ac_word=$2
9227 echo "$as_me:$LINENO: checking for $ac_word" >&5
9228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9229 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9230   echo $ECHO_N "(cached) $ECHO_C" >&6
9231 else
9232   case $AR_FOR_TARGET in
9233   [\\/]* | ?:[\\/]*)
9234   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9235   ;;
9236   *)
9237   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9238 for as_dir in $gcc_cv_tool_dirs
9239 do
9240   IFS=$as_save_IFS
9241   test -z "$as_dir" && as_dir=.
9242   for ac_exec_ext in '' $ac_executable_extensions; do
9243   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9244     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9246     break 2
9247   fi
9248 done
9249 done
9250
9251   ;;
9252 esac
9253 fi
9254 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9255
9256 if test -n "$AR_FOR_TARGET"; then
9257   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9258 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9259 else
9260   echo "$as_me:$LINENO: result: no" >&5
9261 echo "${ECHO_T}no" >&6
9262 fi
9263
9264 fi
9265 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9266
9267
9268 if test -n "$AR_FOR_TARGET"; then
9269   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9270 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9271   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9272 fi
9273
9274 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9275   for ncn_progname in ar; do
9276     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9277 set dummy ${ncn_progname}; ac_word=$2
9278 echo "$as_me:$LINENO: checking for $ac_word" >&5
9279 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9280 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9281   echo $ECHO_N "(cached) $ECHO_C" >&6
9282 else
9283   if test -n "$AR_FOR_TARGET"; then
9284   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9285 else
9286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9287 for as_dir in $PATH
9288 do
9289   IFS=$as_save_IFS
9290   test -z "$as_dir" && as_dir=.
9291   for ac_exec_ext in '' $ac_executable_extensions; do
9292   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9293     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9294     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9295     break 2
9296   fi
9297 done
9298 done
9299
9300 fi
9301 fi
9302 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9303 if test -n "$AR_FOR_TARGET"; then
9304   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9305 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9306 else
9307   echo "$as_me:$LINENO: result: no" >&5
9308 echo "${ECHO_T}no" >&6
9309 fi
9310
9311   done
9312 fi
9313
9314 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9315   for ncn_progname in ar; do
9316     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9317 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9318     if test -x $with_build_time_tools/${ncn_progname}; then
9319       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9320       echo "$as_me:$LINENO: result: yes" >&5
9321 echo "${ECHO_T}yes" >&6
9322       break
9323     else
9324       echo "$as_me:$LINENO: result: no" >&5
9325 echo "${ECHO_T}no" >&6
9326     fi
9327   done
9328 fi
9329
9330 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9331   for ncn_progname in ar; do
9332     if test -n "$ncn_target_tool_prefix"; then
9333       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9334 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9335 echo "$as_me:$LINENO: checking for $ac_word" >&5
9336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9337 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9338   echo $ECHO_N "(cached) $ECHO_C" >&6
9339 else
9340   if test -n "$AR_FOR_TARGET"; then
9341   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9342 else
9343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9344 for as_dir in $PATH
9345 do
9346   IFS=$as_save_IFS
9347   test -z "$as_dir" && as_dir=.
9348   for ac_exec_ext in '' $ac_executable_extensions; do
9349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9350     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9352     break 2
9353   fi
9354 done
9355 done
9356
9357 fi
9358 fi
9359 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9360 if test -n "$AR_FOR_TARGET"; then
9361   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9362 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9363 else
9364   echo "$as_me:$LINENO: result: no" >&5
9365 echo "${ECHO_T}no" >&6
9366 fi
9367
9368     fi
9369     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9370       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9371 set dummy ${ncn_progname}; ac_word=$2
9372 echo "$as_me:$LINENO: checking for $ac_word" >&5
9373 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9374 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9375   echo $ECHO_N "(cached) $ECHO_C" >&6
9376 else
9377   if test -n "$AR_FOR_TARGET"; then
9378   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9379 else
9380 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9381 for as_dir in $PATH
9382 do
9383   IFS=$as_save_IFS
9384   test -z "$as_dir" && as_dir=.
9385   for ac_exec_ext in '' $ac_executable_extensions; do
9386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9387     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9389     break 2
9390   fi
9391 done
9392 done
9393
9394 fi
9395 fi
9396 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9397 if test -n "$AR_FOR_TARGET"; then
9398   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9399 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9400 else
9401   echo "$as_me:$LINENO: result: no" >&5
9402 echo "${ECHO_T}no" >&6
9403 fi
9404
9405     fi
9406     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9407   done
9408 fi
9409
9410 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9411   set dummy ar
9412   if test $build = $target ; then
9413     AR_FOR_TARGET="$2"
9414   else
9415     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9416   fi
9417 else
9418   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9419 fi
9420
9421 else
9422   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9423 fi
9424
9425
9426
9427
9428 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9429   if test -n "$with_build_time_tools"; then
9430     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9431 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9432     if test -x $with_build_time_tools/as; then
9433       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9434       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9435       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9436 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9437     else
9438       echo "$as_me:$LINENO: result: no" >&5
9439 echo "${ECHO_T}no" >&6
9440     fi
9441   elif test $build != $host && test $have_gcc_for_target = yes; then
9442     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9443     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9444     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9445   fi
9446 fi
9447 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9448   # Extract the first word of "as", so it can be a program name with args.
9449 set dummy as; ac_word=$2
9450 echo "$as_me:$LINENO: checking for $ac_word" >&5
9451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9452 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9453   echo $ECHO_N "(cached) $ECHO_C" >&6
9454 else
9455   case $AS_FOR_TARGET in
9456   [\\/]* | ?:[\\/]*)
9457   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9458   ;;
9459   *)
9460   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9461 for as_dir in $gcc_cv_tool_dirs
9462 do
9463   IFS=$as_save_IFS
9464   test -z "$as_dir" && as_dir=.
9465   for ac_exec_ext in '' $ac_executable_extensions; do
9466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9467     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9469     break 2
9470   fi
9471 done
9472 done
9473
9474   ;;
9475 esac
9476 fi
9477 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9478
9479 if test -n "$AS_FOR_TARGET"; then
9480   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9481 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9482 else
9483   echo "$as_me:$LINENO: result: no" >&5
9484 echo "${ECHO_T}no" >&6
9485 fi
9486
9487 fi
9488 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9489
9490
9491 if test -n "$AS_FOR_TARGET"; then
9492   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9493 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9494   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9495 fi
9496
9497 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9498   for ncn_progname in as; do
9499     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9500 set dummy ${ncn_progname}; ac_word=$2
9501 echo "$as_me:$LINENO: checking for $ac_word" >&5
9502 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9503 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9504   echo $ECHO_N "(cached) $ECHO_C" >&6
9505 else
9506   if test -n "$AS_FOR_TARGET"; then
9507   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9508 else
9509 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9510 for as_dir in $PATH
9511 do
9512   IFS=$as_save_IFS
9513   test -z "$as_dir" && as_dir=.
9514   for ac_exec_ext in '' $ac_executable_extensions; do
9515   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9516     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9517     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9518     break 2
9519   fi
9520 done
9521 done
9522
9523 fi
9524 fi
9525 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9526 if test -n "$AS_FOR_TARGET"; then
9527   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9528 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9529 else
9530   echo "$as_me:$LINENO: result: no" >&5
9531 echo "${ECHO_T}no" >&6
9532 fi
9533
9534   done
9535 fi
9536
9537 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9538   for ncn_progname in as; do
9539     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9540 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9541     if test -x $with_build_time_tools/${ncn_progname}; then
9542       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9543       echo "$as_me:$LINENO: result: yes" >&5
9544 echo "${ECHO_T}yes" >&6
9545       break
9546     else
9547       echo "$as_me:$LINENO: result: no" >&5
9548 echo "${ECHO_T}no" >&6
9549     fi
9550   done
9551 fi
9552
9553 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9554   for ncn_progname in as; do
9555     if test -n "$ncn_target_tool_prefix"; then
9556       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9557 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9558 echo "$as_me:$LINENO: checking for $ac_word" >&5
9559 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9560 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9561   echo $ECHO_N "(cached) $ECHO_C" >&6
9562 else
9563   if test -n "$AS_FOR_TARGET"; then
9564   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9565 else
9566 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9567 for as_dir in $PATH
9568 do
9569   IFS=$as_save_IFS
9570   test -z "$as_dir" && as_dir=.
9571   for ac_exec_ext in '' $ac_executable_extensions; do
9572   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9573     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9574     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9575     break 2
9576   fi
9577 done
9578 done
9579
9580 fi
9581 fi
9582 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9583 if test -n "$AS_FOR_TARGET"; then
9584   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9585 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9586 else
9587   echo "$as_me:$LINENO: result: no" >&5
9588 echo "${ECHO_T}no" >&6
9589 fi
9590
9591     fi
9592     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9593       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9594 set dummy ${ncn_progname}; ac_word=$2
9595 echo "$as_me:$LINENO: checking for $ac_word" >&5
9596 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9597 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9598   echo $ECHO_N "(cached) $ECHO_C" >&6
9599 else
9600   if test -n "$AS_FOR_TARGET"; then
9601   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9602 else
9603 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9604 for as_dir in $PATH
9605 do
9606   IFS=$as_save_IFS
9607   test -z "$as_dir" && as_dir=.
9608   for ac_exec_ext in '' $ac_executable_extensions; do
9609   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9610     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9611     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9612     break 2
9613   fi
9614 done
9615 done
9616
9617 fi
9618 fi
9619 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9620 if test -n "$AS_FOR_TARGET"; then
9621   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9622 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9623 else
9624   echo "$as_me:$LINENO: result: no" >&5
9625 echo "${ECHO_T}no" >&6
9626 fi
9627
9628     fi
9629     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9630   done
9631 fi
9632
9633 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9634   set dummy as
9635   if test $build = $target ; then
9636     AS_FOR_TARGET="$2"
9637   else
9638     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9639   fi
9640 else
9641   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9642 fi
9643
9644 else
9645   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9646 fi
9647
9648
9649
9650
9651 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9652   if test -n "$with_build_time_tools"; then
9653     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9654 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9655     if test -x $with_build_time_tools/dlltool; then
9656       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9657       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9658       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9659 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9660     else
9661       echo "$as_me:$LINENO: result: no" >&5
9662 echo "${ECHO_T}no" >&6
9663     fi
9664   elif test $build != $host && test $have_gcc_for_target = yes; then
9665     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9666     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9667     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9668   fi
9669 fi
9670 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9671   # Extract the first word of "dlltool", so it can be a program name with args.
9672 set dummy dlltool; ac_word=$2
9673 echo "$as_me:$LINENO: checking for $ac_word" >&5
9674 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9675 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9676   echo $ECHO_N "(cached) $ECHO_C" >&6
9677 else
9678   case $DLLTOOL_FOR_TARGET in
9679   [\\/]* | ?:[\\/]*)
9680   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9681   ;;
9682   *)
9683   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9684 for as_dir in $gcc_cv_tool_dirs
9685 do
9686   IFS=$as_save_IFS
9687   test -z "$as_dir" && as_dir=.
9688   for ac_exec_ext in '' $ac_executable_extensions; do
9689   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9690     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9691     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9692     break 2
9693   fi
9694 done
9695 done
9696
9697   ;;
9698 esac
9699 fi
9700 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9701
9702 if test -n "$DLLTOOL_FOR_TARGET"; then
9703   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9704 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9705 else
9706   echo "$as_me:$LINENO: result: no" >&5
9707 echo "${ECHO_T}no" >&6
9708 fi
9709
9710 fi
9711 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9712
9713
9714 if test -n "$DLLTOOL_FOR_TARGET"; then
9715   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9716 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9717   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9718 fi
9719
9720 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9721   for ncn_progname in dlltool; do
9722     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9723 set dummy ${ncn_progname}; ac_word=$2
9724 echo "$as_me:$LINENO: checking for $ac_word" >&5
9725 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9726 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9727   echo $ECHO_N "(cached) $ECHO_C" >&6
9728 else
9729   if test -n "$DLLTOOL_FOR_TARGET"; then
9730   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9731 else
9732 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9733 for as_dir in $PATH
9734 do
9735   IFS=$as_save_IFS
9736   test -z "$as_dir" && as_dir=.
9737   for ac_exec_ext in '' $ac_executable_extensions; do
9738   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9739     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9740     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9741     break 2
9742   fi
9743 done
9744 done
9745
9746 fi
9747 fi
9748 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9749 if test -n "$DLLTOOL_FOR_TARGET"; then
9750   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9751 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9752 else
9753   echo "$as_me:$LINENO: result: no" >&5
9754 echo "${ECHO_T}no" >&6
9755 fi
9756
9757   done
9758 fi
9759
9760 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9761   for ncn_progname in dlltool; do
9762     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9763 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9764     if test -x $with_build_time_tools/${ncn_progname}; then
9765       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9766       echo "$as_me:$LINENO: result: yes" >&5
9767 echo "${ECHO_T}yes" >&6
9768       break
9769     else
9770       echo "$as_me:$LINENO: result: no" >&5
9771 echo "${ECHO_T}no" >&6
9772     fi
9773   done
9774 fi
9775
9776 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9777   for ncn_progname in dlltool; do
9778     if test -n "$ncn_target_tool_prefix"; then
9779       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9780 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9781 echo "$as_me:$LINENO: checking for $ac_word" >&5
9782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9783 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9784   echo $ECHO_N "(cached) $ECHO_C" >&6
9785 else
9786   if test -n "$DLLTOOL_FOR_TARGET"; then
9787   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9788 else
9789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9790 for as_dir in $PATH
9791 do
9792   IFS=$as_save_IFS
9793   test -z "$as_dir" && as_dir=.
9794   for ac_exec_ext in '' $ac_executable_extensions; do
9795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9796     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9798     break 2
9799   fi
9800 done
9801 done
9802
9803 fi
9804 fi
9805 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9806 if test -n "$DLLTOOL_FOR_TARGET"; then
9807   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9808 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9809 else
9810   echo "$as_me:$LINENO: result: no" >&5
9811 echo "${ECHO_T}no" >&6
9812 fi
9813
9814     fi
9815     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9816       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9817 set dummy ${ncn_progname}; ac_word=$2
9818 echo "$as_me:$LINENO: checking for $ac_word" >&5
9819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9820 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9821   echo $ECHO_N "(cached) $ECHO_C" >&6
9822 else
9823   if test -n "$DLLTOOL_FOR_TARGET"; then
9824   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9825 else
9826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9827 for as_dir in $PATH
9828 do
9829   IFS=$as_save_IFS
9830   test -z "$as_dir" && as_dir=.
9831   for ac_exec_ext in '' $ac_executable_extensions; do
9832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9833     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9835     break 2
9836   fi
9837 done
9838 done
9839
9840 fi
9841 fi
9842 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9843 if test -n "$DLLTOOL_FOR_TARGET"; then
9844   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9845 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9846 else
9847   echo "$as_me:$LINENO: result: no" >&5
9848 echo "${ECHO_T}no" >&6
9849 fi
9850
9851     fi
9852     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9853   done
9854 fi
9855
9856 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9857   set dummy dlltool
9858   if test $build = $target ; then
9859     DLLTOOL_FOR_TARGET="$2"
9860   else
9861     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9862   fi
9863 else
9864   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9865 fi
9866
9867 else
9868   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9869 fi
9870
9871
9872
9873
9874 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9875   if test -n "$with_build_time_tools"; then
9876     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9877 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9878     if test -x $with_build_time_tools/ld; then
9879       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9880       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9881       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9882 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9883     else
9884       echo "$as_me:$LINENO: result: no" >&5
9885 echo "${ECHO_T}no" >&6
9886     fi
9887   elif test $build != $host && test $have_gcc_for_target = yes; then
9888     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9889     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9890     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9891   fi
9892 fi
9893 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9894   # Extract the first word of "ld", so it can be a program name with args.
9895 set dummy ld; ac_word=$2
9896 echo "$as_me:$LINENO: checking for $ac_word" >&5
9897 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9898 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9899   echo $ECHO_N "(cached) $ECHO_C" >&6
9900 else
9901   case $LD_FOR_TARGET in
9902   [\\/]* | ?:[\\/]*)
9903   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9904   ;;
9905   *)
9906   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9907 for as_dir in $gcc_cv_tool_dirs
9908 do
9909   IFS=$as_save_IFS
9910   test -z "$as_dir" && as_dir=.
9911   for ac_exec_ext in '' $ac_executable_extensions; do
9912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9913     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9915     break 2
9916   fi
9917 done
9918 done
9919
9920   ;;
9921 esac
9922 fi
9923 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9924
9925 if test -n "$LD_FOR_TARGET"; then
9926   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9927 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9928 else
9929   echo "$as_me:$LINENO: result: no" >&5
9930 echo "${ECHO_T}no" >&6
9931 fi
9932
9933 fi
9934 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9935
9936
9937 if test -n "$LD_FOR_TARGET"; then
9938   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9939 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9940   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9941 fi
9942
9943 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9944   for ncn_progname in ld; do
9945     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9946 set dummy ${ncn_progname}; ac_word=$2
9947 echo "$as_me:$LINENO: checking for $ac_word" >&5
9948 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9949 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9950   echo $ECHO_N "(cached) $ECHO_C" >&6
9951 else
9952   if test -n "$LD_FOR_TARGET"; then
9953   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9954 else
9955 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9956 for as_dir in $PATH
9957 do
9958   IFS=$as_save_IFS
9959   test -z "$as_dir" && as_dir=.
9960   for ac_exec_ext in '' $ac_executable_extensions; do
9961   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9962     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9963     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9964     break 2
9965   fi
9966 done
9967 done
9968
9969 fi
9970 fi
9971 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9972 if test -n "$LD_FOR_TARGET"; then
9973   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9974 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9975 else
9976   echo "$as_me:$LINENO: result: no" >&5
9977 echo "${ECHO_T}no" >&6
9978 fi
9979
9980   done
9981 fi
9982
9983 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9984   for ncn_progname in ld; do
9985     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9986 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9987     if test -x $with_build_time_tools/${ncn_progname}; then
9988       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9989       echo "$as_me:$LINENO: result: yes" >&5
9990 echo "${ECHO_T}yes" >&6
9991       break
9992     else
9993       echo "$as_me:$LINENO: result: no" >&5
9994 echo "${ECHO_T}no" >&6
9995     fi
9996   done
9997 fi
9998
9999 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10000   for ncn_progname in ld; do
10001     if test -n "$ncn_target_tool_prefix"; then
10002       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10003 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10004 echo "$as_me:$LINENO: checking for $ac_word" >&5
10005 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10006 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10007   echo $ECHO_N "(cached) $ECHO_C" >&6
10008 else
10009   if test -n "$LD_FOR_TARGET"; then
10010   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10011 else
10012 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10013 for as_dir in $PATH
10014 do
10015   IFS=$as_save_IFS
10016   test -z "$as_dir" && as_dir=.
10017   for ac_exec_ext in '' $ac_executable_extensions; do
10018   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10019     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10020     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10021     break 2
10022   fi
10023 done
10024 done
10025
10026 fi
10027 fi
10028 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10029 if test -n "$LD_FOR_TARGET"; then
10030   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10031 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10032 else
10033   echo "$as_me:$LINENO: result: no" >&5
10034 echo "${ECHO_T}no" >&6
10035 fi
10036
10037     fi
10038     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10039       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10040 set dummy ${ncn_progname}; ac_word=$2
10041 echo "$as_me:$LINENO: checking for $ac_word" >&5
10042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10043 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10044   echo $ECHO_N "(cached) $ECHO_C" >&6
10045 else
10046   if test -n "$LD_FOR_TARGET"; then
10047   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10048 else
10049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10050 for as_dir in $PATH
10051 do
10052   IFS=$as_save_IFS
10053   test -z "$as_dir" && as_dir=.
10054   for ac_exec_ext in '' $ac_executable_extensions; do
10055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10056     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10058     break 2
10059   fi
10060 done
10061 done
10062
10063 fi
10064 fi
10065 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10066 if test -n "$LD_FOR_TARGET"; then
10067   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10068 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10069 else
10070   echo "$as_me:$LINENO: result: no" >&5
10071 echo "${ECHO_T}no" >&6
10072 fi
10073
10074     fi
10075     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10076   done
10077 fi
10078
10079 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10080   set dummy ld
10081   if test $build = $target ; then
10082     LD_FOR_TARGET="$2"
10083   else
10084     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10085   fi
10086 else
10087   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10088 fi
10089
10090 else
10091   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10092 fi
10093
10094
10095
10096
10097 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10098   if test -n "$with_build_time_tools"; then
10099     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10100 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10101     if test -x $with_build_time_tools/lipo; then
10102       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10103       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10104       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10105 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10106     else
10107       echo "$as_me:$LINENO: result: no" >&5
10108 echo "${ECHO_T}no" >&6
10109     fi
10110   elif test $build != $host && test $have_gcc_for_target = yes; then
10111     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10112     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10113     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10114   fi
10115 fi
10116 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10117   # Extract the first word of "lipo", so it can be a program name with args.
10118 set dummy lipo; ac_word=$2
10119 echo "$as_me:$LINENO: checking for $ac_word" >&5
10120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10121 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10122   echo $ECHO_N "(cached) $ECHO_C" >&6
10123 else
10124   case $LIPO_FOR_TARGET in
10125   [\\/]* | ?:[\\/]*)
10126   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10127   ;;
10128   *)
10129   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10130 for as_dir in $gcc_cv_tool_dirs
10131 do
10132   IFS=$as_save_IFS
10133   test -z "$as_dir" && as_dir=.
10134   for ac_exec_ext in '' $ac_executable_extensions; do
10135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10136     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10138     break 2
10139   fi
10140 done
10141 done
10142
10143   ;;
10144 esac
10145 fi
10146 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10147
10148 if test -n "$LIPO_FOR_TARGET"; then
10149   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10150 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10151 else
10152   echo "$as_me:$LINENO: result: no" >&5
10153 echo "${ECHO_T}no" >&6
10154 fi
10155
10156 fi
10157 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10158
10159
10160 if test -n "$LIPO_FOR_TARGET"; then
10161   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10162 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10163   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10164 fi
10165
10166 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10167   for ncn_progname in lipo; do
10168     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10169 set dummy ${ncn_progname}; ac_word=$2
10170 echo "$as_me:$LINENO: checking for $ac_word" >&5
10171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10172 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10173   echo $ECHO_N "(cached) $ECHO_C" >&6
10174 else
10175   if test -n "$LIPO_FOR_TARGET"; then
10176   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10177 else
10178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10179 for as_dir in $PATH
10180 do
10181   IFS=$as_save_IFS
10182   test -z "$as_dir" && as_dir=.
10183   for ac_exec_ext in '' $ac_executable_extensions; do
10184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10185     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10187     break 2
10188   fi
10189 done
10190 done
10191
10192 fi
10193 fi
10194 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10195 if test -n "$LIPO_FOR_TARGET"; then
10196   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10197 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10198 else
10199   echo "$as_me:$LINENO: result: no" >&5
10200 echo "${ECHO_T}no" >&6
10201 fi
10202
10203   done
10204 fi
10205
10206 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10207   for ncn_progname in lipo; do
10208     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10209 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10210     if test -x $with_build_time_tools/${ncn_progname}; then
10211       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10212       echo "$as_me:$LINENO: result: yes" >&5
10213 echo "${ECHO_T}yes" >&6
10214       break
10215     else
10216       echo "$as_me:$LINENO: result: no" >&5
10217 echo "${ECHO_T}no" >&6
10218     fi
10219   done
10220 fi
10221
10222 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10223   for ncn_progname in lipo; do
10224     if test -n "$ncn_target_tool_prefix"; then
10225       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10226 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10227 echo "$as_me:$LINENO: checking for $ac_word" >&5
10228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10229 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10230   echo $ECHO_N "(cached) $ECHO_C" >&6
10231 else
10232   if test -n "$LIPO_FOR_TARGET"; then
10233   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10234 else
10235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10236 for as_dir in $PATH
10237 do
10238   IFS=$as_save_IFS
10239   test -z "$as_dir" && as_dir=.
10240   for ac_exec_ext in '' $ac_executable_extensions; do
10241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10242     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10244     break 2
10245   fi
10246 done
10247 done
10248
10249 fi
10250 fi
10251 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10252 if test -n "$LIPO_FOR_TARGET"; then
10253   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10254 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10255 else
10256   echo "$as_me:$LINENO: result: no" >&5
10257 echo "${ECHO_T}no" >&6
10258 fi
10259
10260     fi
10261     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10262       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10263 set dummy ${ncn_progname}; ac_word=$2
10264 echo "$as_me:$LINENO: checking for $ac_word" >&5
10265 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10266 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10267   echo $ECHO_N "(cached) $ECHO_C" >&6
10268 else
10269   if test -n "$LIPO_FOR_TARGET"; then
10270   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10271 else
10272 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10273 for as_dir in $PATH
10274 do
10275   IFS=$as_save_IFS
10276   test -z "$as_dir" && as_dir=.
10277   for ac_exec_ext in '' $ac_executable_extensions; do
10278   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10279     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10280     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10281     break 2
10282   fi
10283 done
10284 done
10285
10286 fi
10287 fi
10288 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10289 if test -n "$LIPO_FOR_TARGET"; then
10290   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10291 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10292 else
10293   echo "$as_me:$LINENO: result: no" >&5
10294 echo "${ECHO_T}no" >&6
10295 fi
10296
10297     fi
10298     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10299   done
10300 fi
10301
10302 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10303   set dummy lipo
10304   if test $build = $target ; then
10305     LIPO_FOR_TARGET="$2"
10306   else
10307     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10308   fi
10309 else
10310   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10311 fi
10312
10313 else
10314   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10315 fi
10316
10317
10318
10319
10320 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10321   if test -n "$with_build_time_tools"; then
10322     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10323 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10324     if test -x $with_build_time_tools/nm; then
10325       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10326       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10327       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10328 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10329     else
10330       echo "$as_me:$LINENO: result: no" >&5
10331 echo "${ECHO_T}no" >&6
10332     fi
10333   elif test $build != $host && test $have_gcc_for_target = yes; then
10334     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10335     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10336     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10337   fi
10338 fi
10339 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10340   # Extract the first word of "nm", so it can be a program name with args.
10341 set dummy nm; ac_word=$2
10342 echo "$as_me:$LINENO: checking for $ac_word" >&5
10343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10344 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10345   echo $ECHO_N "(cached) $ECHO_C" >&6
10346 else
10347   case $NM_FOR_TARGET in
10348   [\\/]* | ?:[\\/]*)
10349   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10350   ;;
10351   *)
10352   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10353 for as_dir in $gcc_cv_tool_dirs
10354 do
10355   IFS=$as_save_IFS
10356   test -z "$as_dir" && as_dir=.
10357   for ac_exec_ext in '' $ac_executable_extensions; do
10358   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10359     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10361     break 2
10362   fi
10363 done
10364 done
10365
10366   ;;
10367 esac
10368 fi
10369 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10370
10371 if test -n "$NM_FOR_TARGET"; then
10372   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10373 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10374 else
10375   echo "$as_me:$LINENO: result: no" >&5
10376 echo "${ECHO_T}no" >&6
10377 fi
10378
10379 fi
10380 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10381
10382
10383 if test -n "$NM_FOR_TARGET"; then
10384   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10385 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10386   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10387 fi
10388
10389 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10390   for ncn_progname in nm; do
10391     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10392 set dummy ${ncn_progname}; ac_word=$2
10393 echo "$as_me:$LINENO: checking for $ac_word" >&5
10394 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10395 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10396   echo $ECHO_N "(cached) $ECHO_C" >&6
10397 else
10398   if test -n "$NM_FOR_TARGET"; then
10399   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10400 else
10401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10402 for as_dir in $PATH
10403 do
10404   IFS=$as_save_IFS
10405   test -z "$as_dir" && as_dir=.
10406   for ac_exec_ext in '' $ac_executable_extensions; do
10407   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10408     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10409     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10410     break 2
10411   fi
10412 done
10413 done
10414
10415 fi
10416 fi
10417 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10418 if test -n "$NM_FOR_TARGET"; then
10419   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10420 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10421 else
10422   echo "$as_me:$LINENO: result: no" >&5
10423 echo "${ECHO_T}no" >&6
10424 fi
10425
10426   done
10427 fi
10428
10429 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10430   for ncn_progname in nm; do
10431     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10432 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10433     if test -x $with_build_time_tools/${ncn_progname}; then
10434       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10435       echo "$as_me:$LINENO: result: yes" >&5
10436 echo "${ECHO_T}yes" >&6
10437       break
10438     else
10439       echo "$as_me:$LINENO: result: no" >&5
10440 echo "${ECHO_T}no" >&6
10441     fi
10442   done
10443 fi
10444
10445 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10446   for ncn_progname in nm; do
10447     if test -n "$ncn_target_tool_prefix"; then
10448       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10449 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10450 echo "$as_me:$LINENO: checking for $ac_word" >&5
10451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10452 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10453   echo $ECHO_N "(cached) $ECHO_C" >&6
10454 else
10455   if test -n "$NM_FOR_TARGET"; then
10456   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10457 else
10458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10459 for as_dir in $PATH
10460 do
10461   IFS=$as_save_IFS
10462   test -z "$as_dir" && as_dir=.
10463   for ac_exec_ext in '' $ac_executable_extensions; do
10464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10465     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10467     break 2
10468   fi
10469 done
10470 done
10471
10472 fi
10473 fi
10474 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10475 if test -n "$NM_FOR_TARGET"; then
10476   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10477 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10478 else
10479   echo "$as_me:$LINENO: result: no" >&5
10480 echo "${ECHO_T}no" >&6
10481 fi
10482
10483     fi
10484     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10485       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10486 set dummy ${ncn_progname}; ac_word=$2
10487 echo "$as_me:$LINENO: checking for $ac_word" >&5
10488 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10489 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10490   echo $ECHO_N "(cached) $ECHO_C" >&6
10491 else
10492   if test -n "$NM_FOR_TARGET"; then
10493   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10494 else
10495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10496 for as_dir in $PATH
10497 do
10498   IFS=$as_save_IFS
10499   test -z "$as_dir" && as_dir=.
10500   for ac_exec_ext in '' $ac_executable_extensions; do
10501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10502     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10504     break 2
10505   fi
10506 done
10507 done
10508
10509 fi
10510 fi
10511 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10512 if test -n "$NM_FOR_TARGET"; then
10513   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10514 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10515 else
10516   echo "$as_me:$LINENO: result: no" >&5
10517 echo "${ECHO_T}no" >&6
10518 fi
10519
10520     fi
10521     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10522   done
10523 fi
10524
10525 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10526   set dummy nm
10527   if test $build = $target ; then
10528     NM_FOR_TARGET="$2"
10529   else
10530     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10531   fi
10532 else
10533   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10534 fi
10535
10536 else
10537   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10538 fi
10539
10540
10541
10542
10543 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10544   if test -n "$with_build_time_tools"; then
10545     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10546 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10547     if test -x $with_build_time_tools/objdump; then
10548       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10549       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10550       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10551 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10552     else
10553       echo "$as_me:$LINENO: result: no" >&5
10554 echo "${ECHO_T}no" >&6
10555     fi
10556   elif test $build != $host && test $have_gcc_for_target = yes; then
10557     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10558     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10559     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10560   fi
10561 fi
10562 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10563   # Extract the first word of "objdump", so it can be a program name with args.
10564 set dummy objdump; ac_word=$2
10565 echo "$as_me:$LINENO: checking for $ac_word" >&5
10566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10567 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10568   echo $ECHO_N "(cached) $ECHO_C" >&6
10569 else
10570   case $OBJDUMP_FOR_TARGET in
10571   [\\/]* | ?:[\\/]*)
10572   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10573   ;;
10574   *)
10575   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10576 for as_dir in $gcc_cv_tool_dirs
10577 do
10578   IFS=$as_save_IFS
10579   test -z "$as_dir" && as_dir=.
10580   for ac_exec_ext in '' $ac_executable_extensions; do
10581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10582     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10584     break 2
10585   fi
10586 done
10587 done
10588
10589   ;;
10590 esac
10591 fi
10592 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10593
10594 if test -n "$OBJDUMP_FOR_TARGET"; then
10595   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10596 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10597 else
10598   echo "$as_me:$LINENO: result: no" >&5
10599 echo "${ECHO_T}no" >&6
10600 fi
10601
10602 fi
10603 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10604
10605
10606 if test -n "$OBJDUMP_FOR_TARGET"; then
10607   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10608 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10609   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10610 fi
10611
10612 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10613   for ncn_progname in objdump; do
10614     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10615 set dummy ${ncn_progname}; ac_word=$2
10616 echo "$as_me:$LINENO: checking for $ac_word" >&5
10617 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10618 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10619   echo $ECHO_N "(cached) $ECHO_C" >&6
10620 else
10621   if test -n "$OBJDUMP_FOR_TARGET"; then
10622   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10623 else
10624 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10625 for as_dir in $PATH
10626 do
10627   IFS=$as_save_IFS
10628   test -z "$as_dir" && as_dir=.
10629   for ac_exec_ext in '' $ac_executable_extensions; do
10630   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10631     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10632     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10633     break 2
10634   fi
10635 done
10636 done
10637
10638 fi
10639 fi
10640 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10641 if test -n "$OBJDUMP_FOR_TARGET"; then
10642   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10643 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10644 else
10645   echo "$as_me:$LINENO: result: no" >&5
10646 echo "${ECHO_T}no" >&6
10647 fi
10648
10649   done
10650 fi
10651
10652 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10653   for ncn_progname in objdump; do
10654     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10655 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10656     if test -x $with_build_time_tools/${ncn_progname}; then
10657       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10658       echo "$as_me:$LINENO: result: yes" >&5
10659 echo "${ECHO_T}yes" >&6
10660       break
10661     else
10662       echo "$as_me:$LINENO: result: no" >&5
10663 echo "${ECHO_T}no" >&6
10664     fi
10665   done
10666 fi
10667
10668 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10669   for ncn_progname in objdump; do
10670     if test -n "$ncn_target_tool_prefix"; then
10671       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10672 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10673 echo "$as_me:$LINENO: checking for $ac_word" >&5
10674 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10675 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10676   echo $ECHO_N "(cached) $ECHO_C" >&6
10677 else
10678   if test -n "$OBJDUMP_FOR_TARGET"; then
10679   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10680 else
10681 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10682 for as_dir in $PATH
10683 do
10684   IFS=$as_save_IFS
10685   test -z "$as_dir" && as_dir=.
10686   for ac_exec_ext in '' $ac_executable_extensions; do
10687   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10688     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10689     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10690     break 2
10691   fi
10692 done
10693 done
10694
10695 fi
10696 fi
10697 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10698 if test -n "$OBJDUMP_FOR_TARGET"; then
10699   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10700 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10701 else
10702   echo "$as_me:$LINENO: result: no" >&5
10703 echo "${ECHO_T}no" >&6
10704 fi
10705
10706     fi
10707     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10708       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10709 set dummy ${ncn_progname}; ac_word=$2
10710 echo "$as_me:$LINENO: checking for $ac_word" >&5
10711 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10712 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10713   echo $ECHO_N "(cached) $ECHO_C" >&6
10714 else
10715   if test -n "$OBJDUMP_FOR_TARGET"; then
10716   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10717 else
10718 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10719 for as_dir in $PATH
10720 do
10721   IFS=$as_save_IFS
10722   test -z "$as_dir" && as_dir=.
10723   for ac_exec_ext in '' $ac_executable_extensions; do
10724   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10725     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10726     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10727     break 2
10728   fi
10729 done
10730 done
10731
10732 fi
10733 fi
10734 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10735 if test -n "$OBJDUMP_FOR_TARGET"; then
10736   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10737 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10738 else
10739   echo "$as_me:$LINENO: result: no" >&5
10740 echo "${ECHO_T}no" >&6
10741 fi
10742
10743     fi
10744     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10745   done
10746 fi
10747
10748 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10749   set dummy objdump
10750   if test $build = $target ; then
10751     OBJDUMP_FOR_TARGET="$2"
10752   else
10753     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10754   fi
10755 else
10756   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10757 fi
10758
10759 else
10760   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10761 fi
10762
10763
10764
10765
10766 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10767   if test -n "$with_build_time_tools"; then
10768     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10769 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10770     if test -x $with_build_time_tools/ranlib; then
10771       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10772       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10773       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10774 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10775     else
10776       echo "$as_me:$LINENO: result: no" >&5
10777 echo "${ECHO_T}no" >&6
10778     fi
10779   elif test $build != $host && test $have_gcc_for_target = yes; then
10780     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10781     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10782     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10783   fi
10784 fi
10785 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10786   # Extract the first word of "ranlib", so it can be a program name with args.
10787 set dummy ranlib; ac_word=$2
10788 echo "$as_me:$LINENO: checking for $ac_word" >&5
10789 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10790 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10791   echo $ECHO_N "(cached) $ECHO_C" >&6
10792 else
10793   case $RANLIB_FOR_TARGET in
10794   [\\/]* | ?:[\\/]*)
10795   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10796   ;;
10797   *)
10798   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10799 for as_dir in $gcc_cv_tool_dirs
10800 do
10801   IFS=$as_save_IFS
10802   test -z "$as_dir" && as_dir=.
10803   for ac_exec_ext in '' $ac_executable_extensions; do
10804   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10805     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10806     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10807     break 2
10808   fi
10809 done
10810 done
10811
10812   ;;
10813 esac
10814 fi
10815 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10816
10817 if test -n "$RANLIB_FOR_TARGET"; then
10818   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10819 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10820 else
10821   echo "$as_me:$LINENO: result: no" >&5
10822 echo "${ECHO_T}no" >&6
10823 fi
10824
10825 fi
10826 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10827
10828
10829 if test -n "$RANLIB_FOR_TARGET"; then
10830   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10831 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10832   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10833 fi
10834
10835 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10836   for ncn_progname in ranlib; do
10837     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10838 set dummy ${ncn_progname}; ac_word=$2
10839 echo "$as_me:$LINENO: checking for $ac_word" >&5
10840 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10841 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10842   echo $ECHO_N "(cached) $ECHO_C" >&6
10843 else
10844   if test -n "$RANLIB_FOR_TARGET"; then
10845   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10846 else
10847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10848 for as_dir in $PATH
10849 do
10850   IFS=$as_save_IFS
10851   test -z "$as_dir" && as_dir=.
10852   for ac_exec_ext in '' $ac_executable_extensions; do
10853   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10854     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10855     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10856     break 2
10857   fi
10858 done
10859 done
10860
10861 fi
10862 fi
10863 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10864 if test -n "$RANLIB_FOR_TARGET"; then
10865   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10866 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10867 else
10868   echo "$as_me:$LINENO: result: no" >&5
10869 echo "${ECHO_T}no" >&6
10870 fi
10871
10872   done
10873 fi
10874
10875 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10876   for ncn_progname in ranlib; do
10877     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10878 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10879     if test -x $with_build_time_tools/${ncn_progname}; then
10880       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10881       echo "$as_me:$LINENO: result: yes" >&5
10882 echo "${ECHO_T}yes" >&6
10883       break
10884     else
10885       echo "$as_me:$LINENO: result: no" >&5
10886 echo "${ECHO_T}no" >&6
10887     fi
10888   done
10889 fi
10890
10891 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10892   for ncn_progname in ranlib; do
10893     if test -n "$ncn_target_tool_prefix"; then
10894       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10895 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10896 echo "$as_me:$LINENO: checking for $ac_word" >&5
10897 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10898 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10899   echo $ECHO_N "(cached) $ECHO_C" >&6
10900 else
10901   if test -n "$RANLIB_FOR_TARGET"; then
10902   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10903 else
10904 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10905 for as_dir in $PATH
10906 do
10907   IFS=$as_save_IFS
10908   test -z "$as_dir" && as_dir=.
10909   for ac_exec_ext in '' $ac_executable_extensions; do
10910   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10911     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10912     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10913     break 2
10914   fi
10915 done
10916 done
10917
10918 fi
10919 fi
10920 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10921 if test -n "$RANLIB_FOR_TARGET"; then
10922   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10923 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10924 else
10925   echo "$as_me:$LINENO: result: no" >&5
10926 echo "${ECHO_T}no" >&6
10927 fi
10928
10929     fi
10930     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10931       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10932 set dummy ${ncn_progname}; ac_word=$2
10933 echo "$as_me:$LINENO: checking for $ac_word" >&5
10934 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10935 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10936   echo $ECHO_N "(cached) $ECHO_C" >&6
10937 else
10938   if test -n "$RANLIB_FOR_TARGET"; then
10939   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10940 else
10941 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10942 for as_dir in $PATH
10943 do
10944   IFS=$as_save_IFS
10945   test -z "$as_dir" && as_dir=.
10946   for ac_exec_ext in '' $ac_executable_extensions; do
10947   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10948     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10949     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10950     break 2
10951   fi
10952 done
10953 done
10954
10955 fi
10956 fi
10957 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10958 if test -n "$RANLIB_FOR_TARGET"; then
10959   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10960 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10961 else
10962   echo "$as_me:$LINENO: result: no" >&5
10963 echo "${ECHO_T}no" >&6
10964 fi
10965
10966     fi
10967     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10968   done
10969 fi
10970
10971 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10972   set dummy ranlib
10973   if test $build = $target ; then
10974     RANLIB_FOR_TARGET="$2"
10975   else
10976     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10977   fi
10978 else
10979   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10980 fi
10981
10982 else
10983   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10984 fi
10985
10986
10987
10988
10989 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10990   if test -n "$with_build_time_tools"; then
10991     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10992 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10993     if test -x $with_build_time_tools/strip; then
10994       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10995       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10996       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10997 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10998     else
10999       echo "$as_me:$LINENO: result: no" >&5
11000 echo "${ECHO_T}no" >&6
11001     fi
11002   elif test $build != $host && test $have_gcc_for_target = yes; then
11003     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11004     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11005     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11006   fi
11007 fi
11008 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11009   # Extract the first word of "strip", so it can be a program name with args.
11010 set dummy strip; ac_word=$2
11011 echo "$as_me:$LINENO: checking for $ac_word" >&5
11012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11013 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11014   echo $ECHO_N "(cached) $ECHO_C" >&6
11015 else
11016   case $STRIP_FOR_TARGET in
11017   [\\/]* | ?:[\\/]*)
11018   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11019   ;;
11020   *)
11021   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11022 for as_dir in $gcc_cv_tool_dirs
11023 do
11024   IFS=$as_save_IFS
11025   test -z "$as_dir" && as_dir=.
11026   for ac_exec_ext in '' $ac_executable_extensions; do
11027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11028     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11030     break 2
11031   fi
11032 done
11033 done
11034
11035   ;;
11036 esac
11037 fi
11038 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11039
11040 if test -n "$STRIP_FOR_TARGET"; then
11041   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11042 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11043 else
11044   echo "$as_me:$LINENO: result: no" >&5
11045 echo "${ECHO_T}no" >&6
11046 fi
11047
11048 fi
11049 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11050
11051
11052 if test -n "$STRIP_FOR_TARGET"; then
11053   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11054 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11055   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11056 fi
11057
11058 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11059   for ncn_progname in strip; do
11060     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11061 set dummy ${ncn_progname}; ac_word=$2
11062 echo "$as_me:$LINENO: checking for $ac_word" >&5
11063 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11064 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11065   echo $ECHO_N "(cached) $ECHO_C" >&6
11066 else
11067   if test -n "$STRIP_FOR_TARGET"; then
11068   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11069 else
11070 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11071 for as_dir in $PATH
11072 do
11073   IFS=$as_save_IFS
11074   test -z "$as_dir" && as_dir=.
11075   for ac_exec_ext in '' $ac_executable_extensions; do
11076   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11077     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11078     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11079     break 2
11080   fi
11081 done
11082 done
11083
11084 fi
11085 fi
11086 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11087 if test -n "$STRIP_FOR_TARGET"; then
11088   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11089 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11090 else
11091   echo "$as_me:$LINENO: result: no" >&5
11092 echo "${ECHO_T}no" >&6
11093 fi
11094
11095   done
11096 fi
11097
11098 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11099   for ncn_progname in strip; do
11100     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11101 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11102     if test -x $with_build_time_tools/${ncn_progname}; then
11103       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11104       echo "$as_me:$LINENO: result: yes" >&5
11105 echo "${ECHO_T}yes" >&6
11106       break
11107     else
11108       echo "$as_me:$LINENO: result: no" >&5
11109 echo "${ECHO_T}no" >&6
11110     fi
11111   done
11112 fi
11113
11114 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11115   for ncn_progname in strip; do
11116     if test -n "$ncn_target_tool_prefix"; then
11117       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11118 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11119 echo "$as_me:$LINENO: checking for $ac_word" >&5
11120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11121 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11122   echo $ECHO_N "(cached) $ECHO_C" >&6
11123 else
11124   if test -n "$STRIP_FOR_TARGET"; then
11125   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11126 else
11127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11128 for as_dir in $PATH
11129 do
11130   IFS=$as_save_IFS
11131   test -z "$as_dir" && as_dir=.
11132   for ac_exec_ext in '' $ac_executable_extensions; do
11133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11134     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11135     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11136     break 2
11137   fi
11138 done
11139 done
11140
11141 fi
11142 fi
11143 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11144 if test -n "$STRIP_FOR_TARGET"; then
11145   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11146 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11147 else
11148   echo "$as_me:$LINENO: result: no" >&5
11149 echo "${ECHO_T}no" >&6
11150 fi
11151
11152     fi
11153     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11154       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11155 set dummy ${ncn_progname}; ac_word=$2
11156 echo "$as_me:$LINENO: checking for $ac_word" >&5
11157 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11158 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11159   echo $ECHO_N "(cached) $ECHO_C" >&6
11160 else
11161   if test -n "$STRIP_FOR_TARGET"; then
11162   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11163 else
11164 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11165 for as_dir in $PATH
11166 do
11167   IFS=$as_save_IFS
11168   test -z "$as_dir" && as_dir=.
11169   for ac_exec_ext in '' $ac_executable_extensions; do
11170   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11171     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11172     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11173     break 2
11174   fi
11175 done
11176 done
11177
11178 fi
11179 fi
11180 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11181 if test -n "$STRIP_FOR_TARGET"; then
11182   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11183 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11184 else
11185   echo "$as_me:$LINENO: result: no" >&5
11186 echo "${ECHO_T}no" >&6
11187 fi
11188
11189     fi
11190     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11191   done
11192 fi
11193
11194 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11195   set dummy strip
11196   if test $build = $target ; then
11197     STRIP_FOR_TARGET="$2"
11198   else
11199     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11200   fi
11201 else
11202   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11203 fi
11204
11205 else
11206   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11207 fi
11208
11209
11210
11211
11212 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11213   if test -n "$with_build_time_tools"; then
11214     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11215 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11216     if test -x $with_build_time_tools/windres; then
11217       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11218       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11219       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11220 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11221     else
11222       echo "$as_me:$LINENO: result: no" >&5
11223 echo "${ECHO_T}no" >&6
11224     fi
11225   elif test $build != $host && test $have_gcc_for_target = yes; then
11226     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11227     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11228     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11229   fi
11230 fi
11231 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11232   # Extract the first word of "windres", so it can be a program name with args.
11233 set dummy windres; ac_word=$2
11234 echo "$as_me:$LINENO: checking for $ac_word" >&5
11235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11236 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11237   echo $ECHO_N "(cached) $ECHO_C" >&6
11238 else
11239   case $WINDRES_FOR_TARGET in
11240   [\\/]* | ?:[\\/]*)
11241   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11242   ;;
11243   *)
11244   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11245 for as_dir in $gcc_cv_tool_dirs
11246 do
11247   IFS=$as_save_IFS
11248   test -z "$as_dir" && as_dir=.
11249   for ac_exec_ext in '' $ac_executable_extensions; do
11250   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11251     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11252     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11253     break 2
11254   fi
11255 done
11256 done
11257
11258   ;;
11259 esac
11260 fi
11261 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11262
11263 if test -n "$WINDRES_FOR_TARGET"; then
11264   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11265 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11266 else
11267   echo "$as_me:$LINENO: result: no" >&5
11268 echo "${ECHO_T}no" >&6
11269 fi
11270
11271 fi
11272 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11273
11274
11275 if test -n "$WINDRES_FOR_TARGET"; then
11276   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11277 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11278   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11279 fi
11280
11281 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11282   for ncn_progname in windres; do
11283     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11284 set dummy ${ncn_progname}; ac_word=$2
11285 echo "$as_me:$LINENO: checking for $ac_word" >&5
11286 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11287 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11288   echo $ECHO_N "(cached) $ECHO_C" >&6
11289 else
11290   if test -n "$WINDRES_FOR_TARGET"; then
11291   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11292 else
11293 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11294 for as_dir in $PATH
11295 do
11296   IFS=$as_save_IFS
11297   test -z "$as_dir" && as_dir=.
11298   for ac_exec_ext in '' $ac_executable_extensions; do
11299   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11300     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11301     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11302     break 2
11303   fi
11304 done
11305 done
11306
11307 fi
11308 fi
11309 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11310 if test -n "$WINDRES_FOR_TARGET"; then
11311   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11312 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11313 else
11314   echo "$as_me:$LINENO: result: no" >&5
11315 echo "${ECHO_T}no" >&6
11316 fi
11317
11318   done
11319 fi
11320
11321 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11322   for ncn_progname in windres; do
11323     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11324 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11325     if test -x $with_build_time_tools/${ncn_progname}; then
11326       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11327       echo "$as_me:$LINENO: result: yes" >&5
11328 echo "${ECHO_T}yes" >&6
11329       break
11330     else
11331       echo "$as_me:$LINENO: result: no" >&5
11332 echo "${ECHO_T}no" >&6
11333     fi
11334   done
11335 fi
11336
11337 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11338   for ncn_progname in windres; do
11339     if test -n "$ncn_target_tool_prefix"; then
11340       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11341 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11342 echo "$as_me:$LINENO: checking for $ac_word" >&5
11343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11344 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11345   echo $ECHO_N "(cached) $ECHO_C" >&6
11346 else
11347   if test -n "$WINDRES_FOR_TARGET"; then
11348   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11349 else
11350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11351 for as_dir in $PATH
11352 do
11353   IFS=$as_save_IFS
11354   test -z "$as_dir" && as_dir=.
11355   for ac_exec_ext in '' $ac_executable_extensions; do
11356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11357     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11359     break 2
11360   fi
11361 done
11362 done
11363
11364 fi
11365 fi
11366 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11367 if test -n "$WINDRES_FOR_TARGET"; then
11368   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11369 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11370 else
11371   echo "$as_me:$LINENO: result: no" >&5
11372 echo "${ECHO_T}no" >&6
11373 fi
11374
11375     fi
11376     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11377       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11378 set dummy ${ncn_progname}; ac_word=$2
11379 echo "$as_me:$LINENO: checking for $ac_word" >&5
11380 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11381 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11382   echo $ECHO_N "(cached) $ECHO_C" >&6
11383 else
11384   if test -n "$WINDRES_FOR_TARGET"; then
11385   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11386 else
11387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11388 for as_dir in $PATH
11389 do
11390   IFS=$as_save_IFS
11391   test -z "$as_dir" && as_dir=.
11392   for ac_exec_ext in '' $ac_executable_extensions; do
11393   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11394     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11395     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11396     break 2
11397   fi
11398 done
11399 done
11400
11401 fi
11402 fi
11403 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11404 if test -n "$WINDRES_FOR_TARGET"; then
11405   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11406 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11407 else
11408   echo "$as_me:$LINENO: result: no" >&5
11409 echo "${ECHO_T}no" >&6
11410 fi
11411
11412     fi
11413     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11414   done
11415 fi
11416
11417 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11418   set dummy windres
11419   if test $build = $target ; then
11420     WINDRES_FOR_TARGET="$2"
11421   else
11422     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11423   fi
11424 else
11425   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11426 fi
11427
11428 else
11429   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11430 fi
11431
11432
11433
11434
11435 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11436   if test -n "$with_build_time_tools"; then
11437     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11438 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11439     if test -x $with_build_time_tools/windmc; then
11440       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11441       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11442       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11443 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11444     else
11445       echo "$as_me:$LINENO: result: no" >&5
11446 echo "${ECHO_T}no" >&6
11447     fi
11448   elif test $build != $host && test $have_gcc_for_target = yes; then
11449     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11450     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11451     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11452   fi
11453 fi
11454 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11455   # Extract the first word of "windmc", so it can be a program name with args.
11456 set dummy windmc; ac_word=$2
11457 echo "$as_me:$LINENO: checking for $ac_word" >&5
11458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11459 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11460   echo $ECHO_N "(cached) $ECHO_C" >&6
11461 else
11462   case $WINDMC_FOR_TARGET in
11463   [\\/]* | ?:[\\/]*)
11464   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11465   ;;
11466   *)
11467   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11468 for as_dir in $gcc_cv_tool_dirs
11469 do
11470   IFS=$as_save_IFS
11471   test -z "$as_dir" && as_dir=.
11472   for ac_exec_ext in '' $ac_executable_extensions; do
11473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11474     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11476     break 2
11477   fi
11478 done
11479 done
11480
11481   ;;
11482 esac
11483 fi
11484 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11485
11486 if test -n "$WINDMC_FOR_TARGET"; then
11487   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11488 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11489 else
11490   echo "$as_me:$LINENO: result: no" >&5
11491 echo "${ECHO_T}no" >&6
11492 fi
11493
11494 fi
11495 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11496
11497
11498 if test -n "$WINDMC_FOR_TARGET"; then
11499   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11500 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11501   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11502 fi
11503
11504 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11505   for ncn_progname in windmc; do
11506     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11507 set dummy ${ncn_progname}; ac_word=$2
11508 echo "$as_me:$LINENO: checking for $ac_word" >&5
11509 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11510 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11511   echo $ECHO_N "(cached) $ECHO_C" >&6
11512 else
11513   if test -n "$WINDMC_FOR_TARGET"; then
11514   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11515 else
11516 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11517 for as_dir in $PATH
11518 do
11519   IFS=$as_save_IFS
11520   test -z "$as_dir" && as_dir=.
11521   for ac_exec_ext in '' $ac_executable_extensions; do
11522   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11523     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11524     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11525     break 2
11526   fi
11527 done
11528 done
11529
11530 fi
11531 fi
11532 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11533 if test -n "$WINDMC_FOR_TARGET"; then
11534   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11535 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11536 else
11537   echo "$as_me:$LINENO: result: no" >&5
11538 echo "${ECHO_T}no" >&6
11539 fi
11540
11541   done
11542 fi
11543
11544 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11545   for ncn_progname in windmc; do
11546     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11547 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11548     if test -x $with_build_time_tools/${ncn_progname}; then
11549       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11550       echo "$as_me:$LINENO: result: yes" >&5
11551 echo "${ECHO_T}yes" >&6
11552       break
11553     else
11554       echo "$as_me:$LINENO: result: no" >&5
11555 echo "${ECHO_T}no" >&6
11556     fi
11557   done
11558 fi
11559
11560 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11561   for ncn_progname in windmc; do
11562     if test -n "$ncn_target_tool_prefix"; then
11563       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11564 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11565 echo "$as_me:$LINENO: checking for $ac_word" >&5
11566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11567 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11568   echo $ECHO_N "(cached) $ECHO_C" >&6
11569 else
11570   if test -n "$WINDMC_FOR_TARGET"; then
11571   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11572 else
11573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11574 for as_dir in $PATH
11575 do
11576   IFS=$as_save_IFS
11577   test -z "$as_dir" && as_dir=.
11578   for ac_exec_ext in '' $ac_executable_extensions; do
11579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11580     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11582     break 2
11583   fi
11584 done
11585 done
11586
11587 fi
11588 fi
11589 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11590 if test -n "$WINDMC_FOR_TARGET"; then
11591   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11592 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11593 else
11594   echo "$as_me:$LINENO: result: no" >&5
11595 echo "${ECHO_T}no" >&6
11596 fi
11597
11598     fi
11599     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11600       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11601 set dummy ${ncn_progname}; ac_word=$2
11602 echo "$as_me:$LINENO: checking for $ac_word" >&5
11603 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11604 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11605   echo $ECHO_N "(cached) $ECHO_C" >&6
11606 else
11607   if test -n "$WINDMC_FOR_TARGET"; then
11608   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11609 else
11610 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11611 for as_dir in $PATH
11612 do
11613   IFS=$as_save_IFS
11614   test -z "$as_dir" && as_dir=.
11615   for ac_exec_ext in '' $ac_executable_extensions; do
11616   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11617     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11618     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11619     break 2
11620   fi
11621 done
11622 done
11623
11624 fi
11625 fi
11626 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11627 if test -n "$WINDMC_FOR_TARGET"; then
11628   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11629 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11630 else
11631   echo "$as_me:$LINENO: result: no" >&5
11632 echo "${ECHO_T}no" >&6
11633 fi
11634
11635     fi
11636     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11637   done
11638 fi
11639
11640 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11641   set dummy windmc
11642   if test $build = $target ; then
11643     WINDMC_FOR_TARGET="$2"
11644   else
11645     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11646   fi
11647 else
11648   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11649 fi
11650
11651 else
11652   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11653 fi
11654
11655
11656 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11657
11658 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11659 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11660 if test "x${build}" != "x${host}" ; then
11661   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11662     # We already found the complete path
11663     ac_dir=`dirname $AR_FOR_TARGET`
11664     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11665 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11666   else
11667     # Canadian cross, just use what we found
11668     echo "$as_me:$LINENO: result: pre-installed" >&5
11669 echo "${ECHO_T}pre-installed" >&6
11670   fi
11671 else
11672   ok=yes
11673   case " ${configdirs} " in
11674     *" binutils "*) ;;
11675     *) ok=no ;;
11676   esac
11677
11678   if test $ok = yes; then
11679     # An in-tree tool is available and we can use it
11680     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11681     echo "$as_me:$LINENO: result: just compiled" >&5
11682 echo "${ECHO_T}just compiled" >&6
11683   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11684     # We already found the complete path
11685     ac_dir=`dirname $AR_FOR_TARGET`
11686     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11687 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11688   elif test "x$target" = "x$host"; then
11689     # We can use an host tool
11690     AR_FOR_TARGET='$(AR)'
11691     echo "$as_me:$LINENO: result: host tool" >&5
11692 echo "${ECHO_T}host tool" >&6
11693   else
11694     # We need a cross tool
11695     echo "$as_me:$LINENO: result: pre-installed" >&5
11696 echo "${ECHO_T}pre-installed" >&6
11697   fi
11698 fi
11699
11700 echo "$as_me:$LINENO: checking where to find the target as" >&5
11701 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11702 if test "x${build}" != "x${host}" ; then
11703   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11704     # We already found the complete path
11705     ac_dir=`dirname $AS_FOR_TARGET`
11706     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11707 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11708   else
11709     # Canadian cross, just use what we found
11710     echo "$as_me:$LINENO: result: pre-installed" >&5
11711 echo "${ECHO_T}pre-installed" >&6
11712   fi
11713 else
11714   ok=yes
11715   case " ${configdirs} " in
11716     *" gas "*) ;;
11717     *) ok=no ;;
11718   esac
11719
11720   if test $ok = yes; then
11721     # An in-tree tool is available and we can use it
11722     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11723     echo "$as_me:$LINENO: result: just compiled" >&5
11724 echo "${ECHO_T}just compiled" >&6
11725   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11726     # We already found the complete path
11727     ac_dir=`dirname $AS_FOR_TARGET`
11728     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11729 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11730   elif test "x$target" = "x$host"; then
11731     # We can use an host tool
11732     AS_FOR_TARGET='$(AS)'
11733     echo "$as_me:$LINENO: result: host tool" >&5
11734 echo "${ECHO_T}host tool" >&6
11735   else
11736     # We need a cross tool
11737     echo "$as_me:$LINENO: result: pre-installed" >&5
11738 echo "${ECHO_T}pre-installed" >&6
11739   fi
11740 fi
11741
11742 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11743 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11744 if test "x${build}" != "x${host}" ; then
11745   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11746     # We already found the complete path
11747     ac_dir=`dirname $CC_FOR_TARGET`
11748     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11749 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11750   else
11751     # Canadian cross, just use what we found
11752     echo "$as_me:$LINENO: result: pre-installed" >&5
11753 echo "${ECHO_T}pre-installed" >&6
11754   fi
11755 else
11756   ok=yes
11757   case " ${configdirs} " in
11758     *" gcc "*) ;;
11759     *) ok=no ;;
11760   esac
11761
11762   if test $ok = yes; then
11763     # An in-tree tool is available and we can use it
11764     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11765     echo "$as_me:$LINENO: result: just compiled" >&5
11766 echo "${ECHO_T}just compiled" >&6
11767   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11768     # We already found the complete path
11769     ac_dir=`dirname $CC_FOR_TARGET`
11770     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11771 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11772   elif test "x$target" = "x$host"; then
11773     # We can use an host tool
11774     CC_FOR_TARGET='$(CC)'
11775     echo "$as_me:$LINENO: result: host tool" >&5
11776 echo "${ECHO_T}host tool" >&6
11777   else
11778     # We need a cross tool
11779     echo "$as_me:$LINENO: result: pre-installed" >&5
11780 echo "${ECHO_T}pre-installed" >&6
11781   fi
11782 fi
11783
11784 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11785 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11786 if test "x${build}" != "x${host}" ; then
11787   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11788     # We already found the complete path
11789     ac_dir=`dirname $CXX_FOR_TARGET`
11790     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11791 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11792   else
11793     # Canadian cross, just use what we found
11794     echo "$as_me:$LINENO: result: pre-installed" >&5
11795 echo "${ECHO_T}pre-installed" >&6
11796   fi
11797 else
11798   ok=yes
11799   case " ${configdirs} " in
11800     *" gcc "*) ;;
11801     *) ok=no ;;
11802   esac
11803   case ,${enable_languages}, in
11804     *,c++,*) ;;
11805     *) ok=no ;;
11806   esac
11807   if test $ok = yes; then
11808     # An in-tree tool is available and we can use it
11809     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'
11810     echo "$as_me:$LINENO: result: just compiled" >&5
11811 echo "${ECHO_T}just compiled" >&6
11812   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11813     # We already found the complete path
11814     ac_dir=`dirname $CXX_FOR_TARGET`
11815     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11816 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11817   elif test "x$target" = "x$host"; then
11818     # We can use an host tool
11819     CXX_FOR_TARGET='$(CXX)'
11820     echo "$as_me:$LINENO: result: host tool" >&5
11821 echo "${ECHO_T}host tool" >&6
11822   else
11823     # We need a cross tool
11824     echo "$as_me:$LINENO: result: pre-installed" >&5
11825 echo "${ECHO_T}pre-installed" >&6
11826   fi
11827 fi
11828
11829 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11830 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11831 if test "x${build}" != "x${host}" ; then
11832   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11833     # We already found the complete path
11834     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11835     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11836 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11837   else
11838     # Canadian cross, just use what we found
11839     echo "$as_me:$LINENO: result: pre-installed" >&5
11840 echo "${ECHO_T}pre-installed" >&6
11841   fi
11842 else
11843   ok=yes
11844   case " ${configdirs} " in
11845     *" gcc "*) ;;
11846     *) ok=no ;;
11847   esac
11848   case ,${enable_languages}, in
11849     *,c++,*) ;;
11850     *) ok=no ;;
11851   esac
11852   if test $ok = yes; then
11853     # An in-tree tool is available and we can use it
11854     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'
11855     echo "$as_me:$LINENO: result: just compiled" >&5
11856 echo "${ECHO_T}just compiled" >&6
11857   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11858     # We already found the complete path
11859     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11860     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11861 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11862   elif test "x$target" = "x$host"; then
11863     # We can use an host tool
11864     RAW_CXX_FOR_TARGET='$(CXX)'
11865     echo "$as_me:$LINENO: result: host tool" >&5
11866 echo "${ECHO_T}host tool" >&6
11867   else
11868     # We need a cross tool
11869     echo "$as_me:$LINENO: result: pre-installed" >&5
11870 echo "${ECHO_T}pre-installed" >&6
11871   fi
11872 fi
11873
11874 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11875 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11876 if test "x${build}" != "x${host}" ; then
11877   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11878     # We already found the complete path
11879     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11880     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11881 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11882   else
11883     # Canadian cross, just use what we found
11884     echo "$as_me:$LINENO: result: pre-installed" >&5
11885 echo "${ECHO_T}pre-installed" >&6
11886   fi
11887 else
11888   ok=yes
11889   case " ${configdirs} " in
11890     *" binutils "*) ;;
11891     *) ok=no ;;
11892   esac
11893
11894   if test $ok = yes; then
11895     # An in-tree tool is available and we can use it
11896     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11897     echo "$as_me:$LINENO: result: just compiled" >&5
11898 echo "${ECHO_T}just compiled" >&6
11899   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11900     # We already found the complete path
11901     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11902     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11903 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11904   elif test "x$target" = "x$host"; then
11905     # We can use an host tool
11906     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11907     echo "$as_me:$LINENO: result: host tool" >&5
11908 echo "${ECHO_T}host tool" >&6
11909   else
11910     # We need a cross tool
11911     echo "$as_me:$LINENO: result: pre-installed" >&5
11912 echo "${ECHO_T}pre-installed" >&6
11913   fi
11914 fi
11915
11916 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11917 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11918 if test "x${build}" != "x${host}" ; then
11919   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11920     # We already found the complete path
11921     ac_dir=`dirname $GCC_FOR_TARGET`
11922     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11923 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11924   else
11925     # Canadian cross, just use what we found
11926     echo "$as_me:$LINENO: result: pre-installed" >&5
11927 echo "${ECHO_T}pre-installed" >&6
11928   fi
11929 else
11930   ok=yes
11931   case " ${configdirs} " in
11932     *" gcc "*) ;;
11933     *) ok=no ;;
11934   esac
11935
11936   if test $ok = yes; then
11937     # An in-tree tool is available and we can use it
11938     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11939     echo "$as_me:$LINENO: result: just compiled" >&5
11940 echo "${ECHO_T}just compiled" >&6
11941   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11942     # We already found the complete path
11943     ac_dir=`dirname $GCC_FOR_TARGET`
11944     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11945 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11946   elif test "x$target" = "x$host"; then
11947     # We can use an host tool
11948     GCC_FOR_TARGET='$()'
11949     echo "$as_me:$LINENO: result: host tool" >&5
11950 echo "${ECHO_T}host tool" >&6
11951   else
11952     # We need a cross tool
11953     echo "$as_me:$LINENO: result: pre-installed" >&5
11954 echo "${ECHO_T}pre-installed" >&6
11955   fi
11956 fi
11957
11958 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11959 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11960 if test "x${build}" != "x${host}" ; then
11961   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11962     # We already found the complete path
11963     ac_dir=`dirname $GCJ_FOR_TARGET`
11964     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11965 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11966   else
11967     # Canadian cross, just use what we found
11968     echo "$as_me:$LINENO: result: pre-installed" >&5
11969 echo "${ECHO_T}pre-installed" >&6
11970   fi
11971 else
11972   ok=yes
11973   case " ${configdirs} " in
11974     *" gcc "*) ;;
11975     *) ok=no ;;
11976   esac
11977   case ,${enable_languages}, in
11978     *,java,*) ;;
11979     *) ok=no ;;
11980   esac
11981   if test $ok = yes; then
11982     # An in-tree tool is available and we can use it
11983     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11984     echo "$as_me:$LINENO: result: just compiled" >&5
11985 echo "${ECHO_T}just compiled" >&6
11986   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11987     # We already found the complete path
11988     ac_dir=`dirname $GCJ_FOR_TARGET`
11989     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11990 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11991   elif test "x$target" = "x$host"; then
11992     # We can use an host tool
11993     GCJ_FOR_TARGET='$(GCJ)'
11994     echo "$as_me:$LINENO: result: host tool" >&5
11995 echo "${ECHO_T}host tool" >&6
11996   else
11997     # We need a cross tool
11998     echo "$as_me:$LINENO: result: pre-installed" >&5
11999 echo "${ECHO_T}pre-installed" >&6
12000   fi
12001 fi
12002
12003 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12004 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12005 if test "x${build}" != "x${host}" ; then
12006   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12007     # We already found the complete path
12008     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12009     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12010 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12011   else
12012     # Canadian cross, just use what we found
12013     echo "$as_me:$LINENO: result: pre-installed" >&5
12014 echo "${ECHO_T}pre-installed" >&6
12015   fi
12016 else
12017   ok=yes
12018   case " ${configdirs} " in
12019     *" gcc "*) ;;
12020     *) ok=no ;;
12021   esac
12022   case ,${enable_languages}, in
12023     *,fortran,*) ;;
12024     *) ok=no ;;
12025   esac
12026   if test $ok = yes; then
12027     # An in-tree tool is available and we can use it
12028     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12029     echo "$as_me:$LINENO: result: just compiled" >&5
12030 echo "${ECHO_T}just compiled" >&6
12031   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12032     # We already found the complete path
12033     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12034     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12035 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12036   elif test "x$target" = "x$host"; then
12037     # We can use an host tool
12038     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12039     echo "$as_me:$LINENO: result: host tool" >&5
12040 echo "${ECHO_T}host tool" >&6
12041   else
12042     # We need a cross tool
12043     echo "$as_me:$LINENO: result: pre-installed" >&5
12044 echo "${ECHO_T}pre-installed" >&6
12045   fi
12046 fi
12047
12048 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12049 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12050 if test "x${build}" != "x${host}" ; then
12051   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12052     # We already found the complete path
12053     ac_dir=`dirname $LD_FOR_TARGET`
12054     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12055 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12056   else
12057     # Canadian cross, just use what we found
12058     echo "$as_me:$LINENO: result: pre-installed" >&5
12059 echo "${ECHO_T}pre-installed" >&6
12060   fi
12061 else
12062   ok=yes
12063   case " ${configdirs} " in
12064     *" ld "*) ;;
12065     *) ok=no ;;
12066   esac
12067
12068   if test $ok = yes; then
12069     # An in-tree tool is available and we can use it
12070     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12071     echo "$as_me:$LINENO: result: just compiled" >&5
12072 echo "${ECHO_T}just compiled" >&6
12073   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12074     # We already found the complete path
12075     ac_dir=`dirname $LD_FOR_TARGET`
12076     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12077 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12078   elif test "x$target" = "x$host"; then
12079     # We can use an host tool
12080     LD_FOR_TARGET='$(LD)'
12081     echo "$as_me:$LINENO: result: host tool" >&5
12082 echo "${ECHO_T}host tool" >&6
12083   else
12084     # We need a cross tool
12085     echo "$as_me:$LINENO: result: pre-installed" >&5
12086 echo "${ECHO_T}pre-installed" >&6
12087   fi
12088 fi
12089
12090 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12091 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12092 if test "x${build}" != "x${host}" ; then
12093   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12094     # We already found the complete path
12095     ac_dir=`dirname $LIPO_FOR_TARGET`
12096     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12097 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12098   else
12099     # Canadian cross, just use what we found
12100     echo "$as_me:$LINENO: result: pre-installed" >&5
12101 echo "${ECHO_T}pre-installed" >&6
12102   fi
12103 else
12104   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12105     # We already found the complete path
12106     ac_dir=`dirname $LIPO_FOR_TARGET`
12107     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12108 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12109   elif test "x$target" = "x$host"; then
12110     # We can use an host tool
12111     LIPO_FOR_TARGET='$(LIPO)'
12112     echo "$as_me:$LINENO: result: host tool" >&5
12113 echo "${ECHO_T}host tool" >&6
12114   else
12115     # We need a cross tool
12116     echo "$as_me:$LINENO: result: pre-installed" >&5
12117 echo "${ECHO_T}pre-installed" >&6
12118   fi
12119 fi
12120
12121 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12122 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12123 if test "x${build}" != "x${host}" ; then
12124   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12125     # We already found the complete path
12126     ac_dir=`dirname $NM_FOR_TARGET`
12127     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12128 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12129   else
12130     # Canadian cross, just use what we found
12131     echo "$as_me:$LINENO: result: pre-installed" >&5
12132 echo "${ECHO_T}pre-installed" >&6
12133   fi
12134 else
12135   ok=yes
12136   case " ${configdirs} " in
12137     *" binutils "*) ;;
12138     *) ok=no ;;
12139   esac
12140
12141   if test $ok = yes; then
12142     # An in-tree tool is available and we can use it
12143     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12144     echo "$as_me:$LINENO: result: just compiled" >&5
12145 echo "${ECHO_T}just compiled" >&6
12146   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12147     # We already found the complete path
12148     ac_dir=`dirname $NM_FOR_TARGET`
12149     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12150 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12151   elif test "x$target" = "x$host"; then
12152     # We can use an host tool
12153     NM_FOR_TARGET='$(NM)'
12154     echo "$as_me:$LINENO: result: host tool" >&5
12155 echo "${ECHO_T}host tool" >&6
12156   else
12157     # We need a cross tool
12158     echo "$as_me:$LINENO: result: pre-installed" >&5
12159 echo "${ECHO_T}pre-installed" >&6
12160   fi
12161 fi
12162
12163 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12164 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12165 if test "x${build}" != "x${host}" ; then
12166   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12167     # We already found the complete path
12168     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12169     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12170 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12171   else
12172     # Canadian cross, just use what we found
12173     echo "$as_me:$LINENO: result: pre-installed" >&5
12174 echo "${ECHO_T}pre-installed" >&6
12175   fi
12176 else
12177   ok=yes
12178   case " ${configdirs} " in
12179     *" binutils "*) ;;
12180     *) ok=no ;;
12181   esac
12182
12183   if test $ok = yes; then
12184     # An in-tree tool is available and we can use it
12185     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12186     echo "$as_me:$LINENO: result: just compiled" >&5
12187 echo "${ECHO_T}just compiled" >&6
12188   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12189     # We already found the complete path
12190     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12191     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12192 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12193   elif test "x$target" = "x$host"; then
12194     # We can use an host tool
12195     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12196     echo "$as_me:$LINENO: result: host tool" >&5
12197 echo "${ECHO_T}host tool" >&6
12198   else
12199     # We need a cross tool
12200     echo "$as_me:$LINENO: result: pre-installed" >&5
12201 echo "${ECHO_T}pre-installed" >&6
12202   fi
12203 fi
12204
12205 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12206 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12207 if test "x${build}" != "x${host}" ; then
12208   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12209     # We already found the complete path
12210     ac_dir=`dirname $RANLIB_FOR_TARGET`
12211     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12212 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12213   else
12214     # Canadian cross, just use what we found
12215     echo "$as_me:$LINENO: result: pre-installed" >&5
12216 echo "${ECHO_T}pre-installed" >&6
12217   fi
12218 else
12219   ok=yes
12220   case " ${configdirs} " in
12221     *" binutils "*) ;;
12222     *) ok=no ;;
12223   esac
12224
12225   if test $ok = yes; then
12226     # An in-tree tool is available and we can use it
12227     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12228     echo "$as_me:$LINENO: result: just compiled" >&5
12229 echo "${ECHO_T}just compiled" >&6
12230   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12231     # We already found the complete path
12232     ac_dir=`dirname $RANLIB_FOR_TARGET`
12233     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12234 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12235   elif test "x$target" = "x$host"; then
12236     # We can use an host tool
12237     RANLIB_FOR_TARGET='$(RANLIB)'
12238     echo "$as_me:$LINENO: result: host tool" >&5
12239 echo "${ECHO_T}host tool" >&6
12240   else
12241     # We need a cross tool
12242     echo "$as_me:$LINENO: result: pre-installed" >&5
12243 echo "${ECHO_T}pre-installed" >&6
12244   fi
12245 fi
12246
12247 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12248 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12249 if test "x${build}" != "x${host}" ; then
12250   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12251     # We already found the complete path
12252     ac_dir=`dirname $STRIP_FOR_TARGET`
12253     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12254 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12255   else
12256     # Canadian cross, just use what we found
12257     echo "$as_me:$LINENO: result: pre-installed" >&5
12258 echo "${ECHO_T}pre-installed" >&6
12259   fi
12260 else
12261   ok=yes
12262   case " ${configdirs} " in
12263     *" binutils "*) ;;
12264     *) ok=no ;;
12265   esac
12266
12267   if test $ok = yes; then
12268     # An in-tree tool is available and we can use it
12269     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12270     echo "$as_me:$LINENO: result: just compiled" >&5
12271 echo "${ECHO_T}just compiled" >&6
12272   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12273     # We already found the complete path
12274     ac_dir=`dirname $STRIP_FOR_TARGET`
12275     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12276 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12277   elif test "x$target" = "x$host"; then
12278     # We can use an host tool
12279     STRIP_FOR_TARGET='$(STRIP)'
12280     echo "$as_me:$LINENO: result: host tool" >&5
12281 echo "${ECHO_T}host tool" >&6
12282   else
12283     # We need a cross tool
12284     echo "$as_me:$LINENO: result: pre-installed" >&5
12285 echo "${ECHO_T}pre-installed" >&6
12286   fi
12287 fi
12288
12289 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12290 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12291 if test "x${build}" != "x${host}" ; then
12292   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12293     # We already found the complete path
12294     ac_dir=`dirname $WINDRES_FOR_TARGET`
12295     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12296 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12297   else
12298     # Canadian cross, just use what we found
12299     echo "$as_me:$LINENO: result: pre-installed" >&5
12300 echo "${ECHO_T}pre-installed" >&6
12301   fi
12302 else
12303   ok=yes
12304   case " ${configdirs} " in
12305     *" binutils "*) ;;
12306     *) ok=no ;;
12307   esac
12308
12309   if test $ok = yes; then
12310     # An in-tree tool is available and we can use it
12311     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12312     echo "$as_me:$LINENO: result: just compiled" >&5
12313 echo "${ECHO_T}just compiled" >&6
12314   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12315     # We already found the complete path
12316     ac_dir=`dirname $WINDRES_FOR_TARGET`
12317     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12318 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12319   elif test "x$target" = "x$host"; then
12320     # We can use an host tool
12321     WINDRES_FOR_TARGET='$(WINDRES)'
12322     echo "$as_me:$LINENO: result: host tool" >&5
12323 echo "${ECHO_T}host tool" >&6
12324   else
12325     # We need a cross tool
12326     echo "$as_me:$LINENO: result: pre-installed" >&5
12327 echo "${ECHO_T}pre-installed" >&6
12328   fi
12329 fi
12330
12331 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12332 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12333 if test "x${build}" != "x${host}" ; then
12334   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12335     # We already found the complete path
12336     ac_dir=`dirname $WINDMC_FOR_TARGET`
12337     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12338 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12339   else
12340     # Canadian cross, just use what we found
12341     echo "$as_me:$LINENO: result: pre-installed" >&5
12342 echo "${ECHO_T}pre-installed" >&6
12343   fi
12344 else
12345   ok=yes
12346   case " ${configdirs} " in
12347     *" binutils "*) ;;
12348     *) ok=no ;;
12349   esac
12350
12351   if test $ok = yes; then
12352     # An in-tree tool is available and we can use it
12353     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12354     echo "$as_me:$LINENO: result: just compiled" >&5
12355 echo "${ECHO_T}just compiled" >&6
12356   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12357     # We already found the complete path
12358     ac_dir=`dirname $WINDMC_FOR_TARGET`
12359     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12360 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12361   elif test "x$target" = "x$host"; then
12362     # We can use an host tool
12363     WINDMC_FOR_TARGET='$(WINDMC)'
12364     echo "$as_me:$LINENO: result: host tool" >&5
12365 echo "${ECHO_T}host tool" >&6
12366   else
12367     # We need a cross tool
12368     echo "$as_me:$LINENO: result: pre-installed" >&5
12369 echo "${ECHO_T}pre-installed" >&6
12370   fi
12371 fi
12372
12373
12374
12375
12376
12377 # Certain tools may need extra flags.
12378 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12379 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12380 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12381
12382 # When building target libraries, except in a Canadian cross, we use
12383 # the same toolchain as the compiler we just built.
12384 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12385 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12386 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12387 if test $host = $build; then
12388   case " $configdirs " in
12389     *" gcc "*)
12390       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12391       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12392       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12393       ;;
12394   esac
12395 fi
12396
12397
12398
12399
12400
12401 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12402 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12403 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12404 if test "${enable_maintainer_mode+set}" = set; then
12405   enableval="$enable_maintainer_mode"
12406   USE_MAINTAINER_MODE=$enableval
12407 else
12408   USE_MAINTAINER_MODE=no
12409 fi;
12410 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12411 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12412
12413
12414 if test "$USE_MAINTAINER_MODE" = yes; then
12415   MAINTAINER_MODE_TRUE=
12416   MAINTAINER_MODE_FALSE='#'
12417 else
12418   MAINTAINER_MODE_TRUE='#'
12419   MAINTAINER_MODE_FALSE=
12420 fi
12421 MAINT=$MAINTAINER_MODE_TRUE
12422
12423 # ---------------------
12424 # GCC bootstrap support
12425 # ---------------------
12426
12427 # Stage specific cflags for build.
12428 stage1_cflags="-g"
12429 case $build in
12430   vax-*-*)
12431     case ${GCC} in
12432       yes) stage1_cflags="-g -Wa,-J" ;;
12433       *) stage1_cflags="-g -J" ;;
12434     esac ;;
12435 esac
12436
12437 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12438 if test "$GCC" = yes; then
12439   saved_CFLAGS="$CFLAGS"
12440
12441   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12442   CFLAGS="$CFLAGS -fkeep-inline-functions"
12443   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12444 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12445   cat >conftest.$ac_ext <<_ACEOF
12446 /* confdefs.h.  */
12447 _ACEOF
12448 cat confdefs.h >>conftest.$ac_ext
12449 cat >>conftest.$ac_ext <<_ACEOF
12450 /* end confdefs.h.  */
12451
12452 #if (__GNUC__ < 3) \
12453     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12454                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12455 #error http://gcc.gnu.org/PR29382
12456 #endif
12457
12458 int
12459 main ()
12460 {
12461
12462   ;
12463   return 0;
12464 }
12465 _ACEOF
12466 rm -f conftest.$ac_objext
12467 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12468   (eval $ac_compile) 2>conftest.er1
12469   ac_status=$?
12470   grep -v '^ *+' conftest.er1 >conftest.err
12471   rm -f conftest.er1
12472   cat conftest.err >&5
12473   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12474   (exit $ac_status); } &&
12475          { ac_try='test -z "$ac_c_werror_flag"
12476                          || test ! -s conftest.err'
12477   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12478   (eval $ac_try) 2>&5
12479   ac_status=$?
12480   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12481   (exit $ac_status); }; } &&
12482          { ac_try='test -s conftest.$ac_objext'
12483   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12484   (eval $ac_try) 2>&5
12485   ac_status=$?
12486   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12487   (exit $ac_status); }; }; then
12488   echo "$as_me:$LINENO: result: yes" >&5
12489 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12490 else
12491   echo "$as_me: failed program was:" >&5
12492 sed 's/^/| /' conftest.$ac_ext >&5
12493
12494 echo "$as_me:$LINENO: result: no" >&5
12495 echo "${ECHO_T}no" >&6
12496 fi
12497 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12498
12499   CFLAGS="$saved_CFLAGS"
12500 fi
12501
12502
12503
12504 # Enable --enable-checking in stage1 of the compiler.
12505 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12506 if test "${enable_stage1_checking+set}" = set; then
12507   enableval="$enable_stage1_checking"
12508   stage1_checking=--enable-checking=${enable_stage1_checking}
12509 else
12510   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12511   stage1_checking=--enable-checking=yes,types
12512 else
12513   stage1_checking=--enable-checking=$enable_checking,types
12514 fi
12515 fi;
12516
12517
12518 # Enable -Werror in bootstrap stage2 and later.
12519 # Check whether --enable-werror or --disable-werror was given.
12520 if test "${enable_werror+set}" = set; then
12521   enableval="$enable_werror"
12522
12523 else
12524   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12525   enable_werror=yes
12526 else
12527   enable_werror=no
12528 fi
12529 fi;
12530 case ${enable_werror} in
12531   yes) stage2_werror_flag="--enable-werror-always" ;;
12532   *) stage2_werror_flag="" ;;
12533 esac
12534
12535
12536 # Flags needed to enable html installing and building
12537
12538 # Check whether --with-datarootdir or --without-datarootdir was given.
12539 if test "${with_datarootdir+set}" = set; then
12540   withval="$with_datarootdir"
12541   datarootdir="\${prefix}/${withval}"
12542 else
12543   datarootdir="\${prefix}/share"
12544 fi;
12545
12546
12547 # Check whether --with-docdir or --without-docdir was given.
12548 if test "${with_docdir+set}" = set; then
12549   withval="$with_docdir"
12550   docdir="\${prefix}/${withval}"
12551 else
12552   docdir="\${datarootdir}/doc"
12553 fi;
12554
12555
12556 # Check whether --with-pdfdir or --without-pdfdir was given.
12557 if test "${with_pdfdir+set}" = set; then
12558   withval="$with_pdfdir"
12559   pdfdir="\${prefix}/${withval}"
12560 else
12561   pdfdir="\${docdir}"
12562 fi;
12563
12564
12565 # Check whether --with-htmldir or --without-htmldir was given.
12566 if test "${with_htmldir+set}" = set; then
12567   withval="$with_htmldir"
12568   htmldir="\${prefix}/${withval}"
12569 else
12570   htmldir="\${docdir}"
12571 fi;
12572
12573
12574
12575
12576
12577
12578           ac_config_files="$ac_config_files Makefile"
12579 cat >confcache <<\_ACEOF
12580 # This file is a shell script that caches the results of configure
12581 # tests run on this system so they can be shared between configure
12582 # scripts and configure runs, see configure's option --config-cache.
12583 # It is not useful on other systems.  If it contains results you don't
12584 # want to keep, you may remove or edit it.
12585 #
12586 # config.status only pays attention to the cache file if you give it
12587 # the --recheck option to rerun configure.
12588 #
12589 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12590 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12591 # following values.
12592
12593 _ACEOF
12594
12595 # The following way of writing the cache mishandles newlines in values,
12596 # but we know of no workaround that is simple, portable, and efficient.
12597 # So, don't put newlines in cache variables' values.
12598 # Ultrix sh set writes to stderr and can't be redirected directly,
12599 # and sets the high bit in the cache file unless we assign to the vars.
12600 {
12601   (set) 2>&1 |
12602     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12603     *ac_space=\ *)
12604       # `set' does not quote correctly, so add quotes (double-quote
12605       # substitution turns \\\\ into \\, and sed turns \\ into \).
12606       sed -n \
12607         "s/'/'\\\\''/g;
12608           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12609       ;;
12610     *)
12611       # `set' quotes correctly as required by POSIX, so do not add quotes.
12612       sed -n \
12613         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12614       ;;
12615     esac;
12616 } |
12617   sed '
12618      t clear
12619      : clear
12620      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12621      t end
12622      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12623      : end' >>confcache
12624 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12625   if test -w $cache_file; then
12626     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12627     cat confcache >$cache_file
12628   else
12629     echo "not updating unwritable cache $cache_file"
12630   fi
12631 fi
12632 rm -f confcache
12633
12634 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12635 # Let make expand exec_prefix.
12636 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12637
12638 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12639 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12640 # trailing colons and then remove the whole line if VPATH becomes empty
12641 # (actually we leave an empty line to preserve line numbers).
12642 if test "x$srcdir" = x.; then
12643   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12644 s/:*\$(srcdir):*/:/;
12645 s/:*\${srcdir}:*/:/;
12646 s/:*@srcdir@:*/:/;
12647 s/^\([^=]*=[     ]*\):*/\1/;
12648 s/:*$//;
12649 s/^[^=]*=[       ]*$//;
12650 }'
12651 fi
12652
12653 # Transform confdefs.h into DEFS.
12654 # Protect against shell expansion while executing Makefile rules.
12655 # Protect against Makefile macro expansion.
12656 #
12657 # If the first sed substitution is executed (which looks for macros that
12658 # take arguments), then we branch to the quote section.  Otherwise,
12659 # look for a macro that doesn't take arguments.
12660 cat >confdef2opt.sed <<\_ACEOF
12661 t clear
12662 : clear
12663 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12664 t quote
12665 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12666 t quote
12667 d
12668 : quote
12669 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12670 s,\[,\\&,g
12671 s,\],\\&,g
12672 s,\$,$$,g
12673 p
12674 _ACEOF
12675 # We use echo to avoid assuming a particular line-breaking character.
12676 # The extra dot is to prevent the shell from consuming trailing
12677 # line-breaks from the sub-command output.  A line-break within
12678 # single-quotes doesn't work because, if this script is created in a
12679 # platform that uses two characters for line-breaks (e.g., DOS), tr
12680 # would break.
12681 ac_LF_and_DOT=`echo; echo .`
12682 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12683 rm -f confdef2opt.sed
12684
12685
12686 ac_libobjs=
12687 ac_ltlibobjs=
12688 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12689   # 1. Remove the extension, and $U if already installed.
12690   ac_i=`echo "$ac_i" |
12691          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12692   # 2. Add them.
12693   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12694   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12695 done
12696 LIBOBJS=$ac_libobjs
12697
12698 LTLIBOBJS=$ac_ltlibobjs
12699
12700
12701
12702 : ${CONFIG_STATUS=./config.status}
12703 ac_clean_files_save=$ac_clean_files
12704 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12705 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12706 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12707 cat >$CONFIG_STATUS <<_ACEOF
12708 #! $SHELL
12709 # Generated by $as_me.
12710 # Run this file to recreate the current configuration.
12711 # Compiler output produced by configure, useful for debugging
12712 # configure, is in config.log if it exists.
12713
12714 debug=false
12715 ac_cs_recheck=false
12716 ac_cs_silent=false
12717 SHELL=\${CONFIG_SHELL-$SHELL}
12718 _ACEOF
12719
12720 cat >>$CONFIG_STATUS <<\_ACEOF
12721 ## --------------------- ##
12722 ## M4sh Initialization.  ##
12723 ## --------------------- ##
12724
12725 # Be Bourne compatible
12726 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12727   emulate sh
12728   NULLCMD=:
12729   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12730   # is contrary to our usage.  Disable this feature.
12731   alias -g '${1+"$@"}'='"$@"'
12732 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12733   set -o posix
12734 fi
12735 DUALCASE=1; export DUALCASE # for MKS sh
12736
12737 # Support unset when possible.
12738 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12739   as_unset=unset
12740 else
12741   as_unset=false
12742 fi
12743
12744
12745 # Work around bugs in pre-3.0 UWIN ksh.
12746 $as_unset ENV MAIL MAILPATH
12747 PS1='$ '
12748 PS2='> '
12749 PS4='+ '
12750
12751 # NLS nuisances.
12752 for as_var in \
12753   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12754   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12755   LC_TELEPHONE LC_TIME
12756 do
12757   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12758     eval $as_var=C; export $as_var
12759   else
12760     $as_unset $as_var
12761   fi
12762 done
12763
12764 # Required to use basename.
12765 if expr a : '\(a\)' >/dev/null 2>&1; then
12766   as_expr=expr
12767 else
12768   as_expr=false
12769 fi
12770
12771 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12772   as_basename=basename
12773 else
12774   as_basename=false
12775 fi
12776
12777
12778 # Name of the executable.
12779 as_me=`$as_basename "$0" ||
12780 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12781          X"$0" : 'X\(//\)$' \| \
12782          X"$0" : 'X\(/\)$' \| \
12783          .     : '\(.\)' 2>/dev/null ||
12784 echo X/"$0" |
12785     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12786           /^X\/\(\/\/\)$/{ s//\1/; q; }
12787           /^X\/\(\/\).*/{ s//\1/; q; }
12788           s/.*/./; q'`
12789
12790
12791 # PATH needs CR, and LINENO needs CR and PATH.
12792 # Avoid depending upon Character Ranges.
12793 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12794 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12795 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12796 as_cr_digits='0123456789'
12797 as_cr_alnum=$as_cr_Letters$as_cr_digits
12798
12799 # The user is always right.
12800 if test "${PATH_SEPARATOR+set}" != set; then
12801   echo "#! /bin/sh" >conf$$.sh
12802   echo  "exit 0"   >>conf$$.sh
12803   chmod +x conf$$.sh
12804   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12805     PATH_SEPARATOR=';'
12806   else
12807     PATH_SEPARATOR=:
12808   fi
12809   rm -f conf$$.sh
12810 fi
12811
12812
12813   as_lineno_1=$LINENO
12814   as_lineno_2=$LINENO
12815   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12816   test "x$as_lineno_1" != "x$as_lineno_2" &&
12817   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12818   # Find who we are.  Look in the path if we contain no path at all
12819   # relative or not.
12820   case $0 in
12821     *[\\/]* ) as_myself=$0 ;;
12822     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12823 for as_dir in $PATH
12824 do
12825   IFS=$as_save_IFS
12826   test -z "$as_dir" && as_dir=.
12827   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12828 done
12829
12830        ;;
12831   esac
12832   # We did not find ourselves, most probably we were run as `sh COMMAND'
12833   # in which case we are not to be found in the path.
12834   if test "x$as_myself" = x; then
12835     as_myself=$0
12836   fi
12837   if test ! -f "$as_myself"; then
12838     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12839 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12840    { (exit 1); exit 1; }; }
12841   fi
12842   case $CONFIG_SHELL in
12843   '')
12844     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12845 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12846 do
12847   IFS=$as_save_IFS
12848   test -z "$as_dir" && as_dir=.
12849   for as_base in sh bash ksh sh5; do
12850          case $as_dir in
12851          /*)
12852            if ("$as_dir/$as_base" -c '
12853   as_lineno_1=$LINENO
12854   as_lineno_2=$LINENO
12855   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12856   test "x$as_lineno_1" != "x$as_lineno_2" &&
12857   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12858              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12859              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12860              CONFIG_SHELL=$as_dir/$as_base
12861              export CONFIG_SHELL
12862              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12863            fi;;
12864          esac
12865        done
12866 done
12867 ;;
12868   esac
12869
12870   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12871   # uniformly replaced by the line number.  The first 'sed' inserts a
12872   # line-number line before each line; the second 'sed' does the real
12873   # work.  The second script uses 'N' to pair each line-number line
12874   # with the numbered line, and appends trailing '-' during
12875   # substitution so that $LINENO is not a special case at line end.
12876   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12877   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12878   sed '=' <$as_myself |
12879     sed '
12880       N
12881       s,$,-,
12882       : loop
12883       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12884       t loop
12885       s,-$,,
12886       s,^['$as_cr_digits']*\n,,
12887     ' >$as_me.lineno &&
12888   chmod +x $as_me.lineno ||
12889     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12890 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12891    { (exit 1); exit 1; }; }
12892
12893   # Don't try to exec as it changes $[0], causing all sort of problems
12894   # (the dirname of $[0] is not the place where we might find the
12895   # original and so on.  Autoconf is especially sensible to this).
12896   . ./$as_me.lineno
12897   # Exit status is that of the last command.
12898   exit
12899 }
12900
12901
12902 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12903   *c*,-n*) ECHO_N= ECHO_C='
12904 ' ECHO_T='      ' ;;
12905   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12906   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12907 esac
12908
12909 if expr a : '\(a\)' >/dev/null 2>&1; then
12910   as_expr=expr
12911 else
12912   as_expr=false
12913 fi
12914
12915 rm -f conf$$ conf$$.exe conf$$.file
12916 echo >conf$$.file
12917 if ln -s conf$$.file conf$$ 2>/dev/null; then
12918   # We could just check for DJGPP; but this test a) works b) is more generic
12919   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12920   if test -f conf$$.exe; then
12921     # Don't use ln at all; we don't have any links
12922     as_ln_s='cp -p'
12923   else
12924     as_ln_s='ln -s'
12925   fi
12926 elif ln conf$$.file conf$$ 2>/dev/null; then
12927   as_ln_s=ln
12928 else
12929   as_ln_s='cp -p'
12930 fi
12931 rm -f conf$$ conf$$.exe conf$$.file
12932
12933 if mkdir -p . 2>/dev/null; then
12934   as_mkdir_p=:
12935 else
12936   test -d ./-p && rmdir ./-p
12937   as_mkdir_p=false
12938 fi
12939
12940 as_executable_p="test -f"
12941
12942 # Sed expression to map a string onto a valid CPP name.
12943 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12944
12945 # Sed expression to map a string onto a valid variable name.
12946 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12947
12948
12949 # IFS
12950 # We need space, tab and new line, in precisely that order.
12951 as_nl='
12952 '
12953 IFS="   $as_nl"
12954
12955 # CDPATH.
12956 $as_unset CDPATH
12957
12958 exec 6>&1
12959
12960 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12961 # report actual input values of CONFIG_FILES etc. instead of their
12962 # values after options handling.  Logging --version etc. is OK.
12963 exec 5>>config.log
12964 {
12965   echo
12966   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12967 ## Running $as_me. ##
12968 _ASBOX
12969 } >&5
12970 cat >&5 <<_CSEOF
12971
12972 This file was extended by $as_me, which was
12973 generated by GNU Autoconf 2.59.  Invocation command line was
12974
12975   CONFIG_FILES    = $CONFIG_FILES
12976   CONFIG_HEADERS  = $CONFIG_HEADERS
12977   CONFIG_LINKS    = $CONFIG_LINKS
12978   CONFIG_COMMANDS = $CONFIG_COMMANDS
12979   $ $0 $@
12980
12981 _CSEOF
12982 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12983 echo >&5
12984 _ACEOF
12985
12986 # Files that config.status was made for.
12987 if test -n "$ac_config_files"; then
12988   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12989 fi
12990
12991 if test -n "$ac_config_headers"; then
12992   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12993 fi
12994
12995 if test -n "$ac_config_links"; then
12996   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12997 fi
12998
12999 if test -n "$ac_config_commands"; then
13000   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13001 fi
13002
13003 cat >>$CONFIG_STATUS <<\_ACEOF
13004
13005 ac_cs_usage="\
13006 \`$as_me' instantiates files from templates according to the
13007 current configuration.
13008
13009 Usage: $0 [OPTIONS] [FILE]...
13010
13011   -h, --help       print this help, then exit
13012   -V, --version    print version number, then exit
13013   -q, --quiet      do not print progress messages
13014   -d, --debug      don't remove temporary files
13015       --recheck    update $as_me by reconfiguring in the same conditions
13016   --file=FILE[:TEMPLATE]
13017                    instantiate the configuration file FILE
13018
13019 Configuration files:
13020 $config_files
13021
13022 Report bugs to <bug-autoconf@gnu.org>."
13023 _ACEOF
13024
13025 cat >>$CONFIG_STATUS <<_ACEOF
13026 ac_cs_version="\\
13027 config.status
13028 configured by $0, generated by GNU Autoconf 2.59,
13029   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13030
13031 Copyright (C) 2003 Free Software Foundation, Inc.
13032 This config.status script is free software; the Free Software Foundation
13033 gives unlimited permission to copy, distribute and modify it."
13034 srcdir=$srcdir
13035 INSTALL="$INSTALL"
13036 _ACEOF
13037
13038 cat >>$CONFIG_STATUS <<\_ACEOF
13039 # If no file are specified by the user, then we need to provide default
13040 # value.  By we need to know if files were specified by the user.
13041 ac_need_defaults=:
13042 while test $# != 0
13043 do
13044   case $1 in
13045   --*=*)
13046     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13047     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13048     ac_shift=:
13049     ;;
13050   -*)
13051     ac_option=$1
13052     ac_optarg=$2
13053     ac_shift=shift
13054     ;;
13055   *) # This is not an option, so the user has probably given explicit
13056      # arguments.
13057      ac_option=$1
13058      ac_need_defaults=false;;
13059   esac
13060
13061   case $ac_option in
13062   # Handling of the options.
13063 _ACEOF
13064 cat >>$CONFIG_STATUS <<\_ACEOF
13065   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13066     ac_cs_recheck=: ;;
13067   --version | --vers* | -V )
13068     echo "$ac_cs_version"; exit 0 ;;
13069   --he | --h)
13070     # Conflict between --help and --header
13071     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13072 Try \`$0 --help' for more information." >&5
13073 echo "$as_me: error: ambiguous option: $1
13074 Try \`$0 --help' for more information." >&2;}
13075    { (exit 1); exit 1; }; };;
13076   --help | --hel | -h )
13077     echo "$ac_cs_usage"; exit 0 ;;
13078   --debug | --d* | -d )
13079     debug=: ;;
13080   --file | --fil | --fi | --f )
13081     $ac_shift
13082     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13083     ac_need_defaults=false;;
13084   --header | --heade | --head | --hea )
13085     $ac_shift
13086     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13087     ac_need_defaults=false;;
13088   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13089   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13090     ac_cs_silent=: ;;
13091
13092   # This is an error.
13093   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13094 Try \`$0 --help' for more information." >&5
13095 echo "$as_me: error: unrecognized option: $1
13096 Try \`$0 --help' for more information." >&2;}
13097    { (exit 1); exit 1; }; } ;;
13098
13099   *) ac_config_targets="$ac_config_targets $1" ;;
13100
13101   esac
13102   shift
13103 done
13104
13105 ac_configure_extra_args=
13106
13107 if $ac_cs_silent; then
13108   exec 6>/dev/null
13109   ac_configure_extra_args="$ac_configure_extra_args --silent"
13110 fi
13111
13112 _ACEOF
13113 cat >>$CONFIG_STATUS <<_ACEOF
13114 if \$ac_cs_recheck; then
13115   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13116   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13117 fi
13118
13119 _ACEOF
13120
13121
13122
13123
13124
13125 cat >>$CONFIG_STATUS <<\_ACEOF
13126 for ac_config_target in $ac_config_targets
13127 do
13128   case "$ac_config_target" in
13129   # Handling of arguments.
13130   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13131   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13132 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13133    { (exit 1); exit 1; }; };;
13134   esac
13135 done
13136
13137 # If the user did not use the arguments to specify the items to instantiate,
13138 # then the envvar interface is used.  Set only those that are not.
13139 # We use the long form for the default assignment because of an extremely
13140 # bizarre bug on SunOS 4.1.3.
13141 if $ac_need_defaults; then
13142   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13143 fi
13144
13145 # Have a temporary directory for convenience.  Make it in the build tree
13146 # simply because there is no reason to put it here, and in addition,
13147 # creating and moving files from /tmp can sometimes cause problems.
13148 # Create a temporary directory, and hook for its removal unless debugging.
13149 $debug ||
13150 {
13151   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13152   trap '{ (exit 1); exit 1; }' 1 2 13 15
13153 }
13154
13155 # Create a (secure) tmp directory for tmp files.
13156
13157 {
13158   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13159   test -n "$tmp" && test -d "$tmp"
13160 }  ||
13161 {
13162   tmp=./confstat$$-$RANDOM
13163   (umask 077 && mkdir $tmp)
13164 } ||
13165 {
13166    echo "$me: cannot create a temporary directory in ." >&2
13167    { (exit 1); exit 1; }
13168 }
13169
13170 _ACEOF
13171
13172 cat >>$CONFIG_STATUS <<_ACEOF
13173
13174 #
13175 # CONFIG_FILES section.
13176 #
13177
13178 # No need to generate the scripts if there are no CONFIG_FILES.
13179 # This happens for instance when ./config.status config.h
13180 if test -n "\$CONFIG_FILES"; then
13181   # Protect against being on the right side of a sed subst in config.status.
13182   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13183    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13184 s,@SHELL@,$SHELL,;t t
13185 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13186 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13187 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13188 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13189 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13190 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13191 s,@exec_prefix@,$exec_prefix,;t t
13192 s,@prefix@,$prefix,;t t
13193 s,@program_transform_name@,$program_transform_name,;t t
13194 s,@bindir@,$bindir,;t t
13195 s,@sbindir@,$sbindir,;t t
13196 s,@libexecdir@,$libexecdir,;t t
13197 s,@datadir@,$datadir,;t t
13198 s,@sysconfdir@,$sysconfdir,;t t
13199 s,@sharedstatedir@,$sharedstatedir,;t t
13200 s,@localstatedir@,$localstatedir,;t t
13201 s,@libdir@,$libdir,;t t
13202 s,@includedir@,$includedir,;t t
13203 s,@oldincludedir@,$oldincludedir,;t t
13204 s,@infodir@,$infodir,;t t
13205 s,@mandir@,$mandir,;t t
13206 s,@build_alias@,$build_alias,;t t
13207 s,@host_alias@,$host_alias,;t t
13208 s,@target_alias@,$target_alias,;t t
13209 s,@DEFS@,$DEFS,;t t
13210 s,@ECHO_C@,$ECHO_C,;t t
13211 s,@ECHO_N@,$ECHO_N,;t t
13212 s,@ECHO_T@,$ECHO_T,;t t
13213 s,@LIBS@,$LIBS,;t t
13214 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13215 s,@build@,$build,;t t
13216 s,@build_cpu@,$build_cpu,;t t
13217 s,@build_vendor@,$build_vendor,;t t
13218 s,@build_os@,$build_os,;t t
13219 s,@build_noncanonical@,$build_noncanonical,;t t
13220 s,@host_noncanonical@,$host_noncanonical,;t t
13221 s,@target_noncanonical@,$target_noncanonical,;t t
13222 s,@host@,$host,;t t
13223 s,@host_cpu@,$host_cpu,;t t
13224 s,@host_vendor@,$host_vendor,;t t
13225 s,@host_os@,$host_os,;t t
13226 s,@target@,$target,;t t
13227 s,@target_cpu@,$target_cpu,;t t
13228 s,@target_vendor@,$target_vendor,;t t
13229 s,@target_os@,$target_os,;t t
13230 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13231 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13232 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13233 s,@LN@,$LN,;t t
13234 s,@LN_S@,$LN_S,;t t
13235 s,@build_libsubdir@,$build_libsubdir,;t t
13236 s,@build_subdir@,$build_subdir,;t t
13237 s,@host_subdir@,$host_subdir,;t t
13238 s,@target_subdir@,$target_subdir,;t t
13239 s,@CC@,$CC,;t t
13240 s,@CFLAGS@,$CFLAGS,;t t
13241 s,@LDFLAGS@,$LDFLAGS,;t t
13242 s,@CPPFLAGS@,$CPPFLAGS,;t t
13243 s,@ac_ct_CC@,$ac_ct_CC,;t t
13244 s,@EXEEXT@,$EXEEXT,;t t
13245 s,@OBJEXT@,$OBJEXT,;t t
13246 s,@CXX@,$CXX,;t t
13247 s,@CXXFLAGS@,$CXXFLAGS,;t t
13248 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13249 s,@GNATBIND@,$GNATBIND,;t t
13250 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13251 s,@GNATMAKE@,$GNATMAKE,;t t
13252 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13253 s,@do_compare@,$do_compare,;t t
13254 s,@gmplibs@,$gmplibs,;t t
13255 s,@gmpinc@,$gmpinc,;t t
13256 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13257 s,@ppllibs@,$ppllibs,;t t
13258 s,@pplinc@,$pplinc,;t t
13259 s,@clooglibs@,$clooglibs,;t t
13260 s,@clooginc@,$clooginc,;t t
13261 s,@stage1_languages@,$stage1_languages,;t t
13262 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13263 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13264 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13265 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13266 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13267 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13268 s,@tooldir@,$tooldir,;t t
13269 s,@build_tooldir@,$build_tooldir,;t t
13270 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13271 s,@GDB_TK@,$GDB_TK,;t t
13272 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13273 s,@build_configargs@,$build_configargs,;t t
13274 s,@build_configdirs@,$build_configdirs,;t t
13275 s,@host_configargs@,$host_configargs,;t t
13276 s,@configdirs@,$configdirs,;t t
13277 s,@target_configargs@,$target_configargs,;t t
13278 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13279 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13280 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13281 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13282 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13283 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13284 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13285 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13286 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13287 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13288 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13289 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13290 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13291 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13292 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13293 s,@config_shell@,$config_shell,;t t
13294 s,@YACC@,$YACC,;t t
13295 s,@BISON@,$BISON,;t t
13296 s,@M4@,$M4,;t t
13297 s,@LEX@,$LEX,;t t
13298 s,@FLEX@,$FLEX,;t t
13299 s,@MAKEINFO@,$MAKEINFO,;t t
13300 s,@EXPECT@,$EXPECT,;t t
13301 s,@RUNTEST@,$RUNTEST,;t t
13302 s,@AR@,$AR,;t t
13303 s,@AS@,$AS,;t t
13304 s,@DLLTOOL@,$DLLTOOL,;t t
13305 s,@LD@,$LD,;t t
13306 s,@LIPO@,$LIPO,;t t
13307 s,@NM@,$NM,;t t
13308 s,@RANLIB@,$RANLIB,;t t
13309 s,@STRIP@,$STRIP,;t t
13310 s,@WINDRES@,$WINDRES,;t t
13311 s,@WINDMC@,$WINDMC,;t t
13312 s,@OBJCOPY@,$OBJCOPY,;t t
13313 s,@OBJDUMP@,$OBJDUMP,;t t
13314 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13315 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13316 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13317 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13318 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13319 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13320 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13321 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13322 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13323 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13324 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13325 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13326 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13327 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13328 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13329 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13330 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13331 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13332 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13333 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13334 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13335 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13336 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13337 s,@MAINT@,$MAINT,;t t
13338 s,@stage1_cflags@,$stage1_cflags,;t t
13339 s,@stage1_checking@,$stage1_checking,;t t
13340 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13341 s,@datarootdir@,$datarootdir,;t t
13342 s,@docdir@,$docdir,;t t
13343 s,@pdfdir@,$pdfdir,;t t
13344 s,@htmldir@,$htmldir,;t t
13345 s,@LIBOBJS@,$LIBOBJS,;t t
13346 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13347 /@serialization_dependencies@/r $serialization_dependencies
13348 s,@serialization_dependencies@,,;t t
13349 /@host_makefile_frag@/r $host_makefile_frag
13350 s,@host_makefile_frag@,,;t t
13351 /@target_makefile_frag@/r $target_makefile_frag
13352 s,@target_makefile_frag@,,;t t
13353 /@alphaieee_frag@/r $alphaieee_frag
13354 s,@alphaieee_frag@,,;t t
13355 /@ospace_frag@/r $ospace_frag
13356 s,@ospace_frag@,,;t t
13357 CEOF
13358
13359 _ACEOF
13360
13361   cat >>$CONFIG_STATUS <<\_ACEOF
13362   # Split the substitutions into bite-sized pieces for seds with
13363   # small command number limits, like on Digital OSF/1 and HP-UX.
13364   ac_max_sed_lines=48
13365   ac_sed_frag=1 # Number of current file.
13366   ac_beg=1 # First line for current file.
13367   ac_end=$ac_max_sed_lines # Line after last line for current file.
13368   ac_more_lines=:
13369   ac_sed_cmds=
13370   while $ac_more_lines; do
13371     if test $ac_beg -gt 1; then
13372       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13373     else
13374       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13375     fi
13376     if test ! -s $tmp/subs.frag; then
13377       ac_more_lines=false
13378     else
13379       # The purpose of the label and of the branching condition is to
13380       # speed up the sed processing (if there are no `@' at all, there
13381       # is no need to browse any of the substitutions).
13382       # These are the two extra sed commands mentioned above.
13383       (echo ':t
13384   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13385       if test -z "$ac_sed_cmds"; then
13386         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13387       else
13388         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13389       fi
13390       ac_sed_frag=`expr $ac_sed_frag + 1`
13391       ac_beg=$ac_end
13392       ac_end=`expr $ac_end + $ac_max_sed_lines`
13393     fi
13394   done
13395   if test -z "$ac_sed_cmds"; then
13396     ac_sed_cmds=cat
13397   fi
13398 fi # test -n "$CONFIG_FILES"
13399
13400 _ACEOF
13401 cat >>$CONFIG_STATUS <<\_ACEOF
13402 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13403   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13404   case $ac_file in
13405   - | *:- | *:-:* ) # input from stdin
13406         cat >$tmp/stdin
13407         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13408         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13409   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13410         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13411   * )   ac_file_in=$ac_file.in ;;
13412   esac
13413
13414   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13415   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13416 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13417          X"$ac_file" : 'X\(//\)[^/]' \| \
13418          X"$ac_file" : 'X\(//\)$' \| \
13419          X"$ac_file" : 'X\(/\)' \| \
13420          .     : '\(.\)' 2>/dev/null ||
13421 echo X"$ac_file" |
13422     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13423           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13424           /^X\(\/\/\)$/{ s//\1/; q; }
13425           /^X\(\/\).*/{ s//\1/; q; }
13426           s/.*/./; q'`
13427   { if $as_mkdir_p; then
13428     mkdir -p "$ac_dir"
13429   else
13430     as_dir="$ac_dir"
13431     as_dirs=
13432     while test ! -d "$as_dir"; do
13433       as_dirs="$as_dir $as_dirs"
13434       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13435 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13436          X"$as_dir" : 'X\(//\)[^/]' \| \
13437          X"$as_dir" : 'X\(//\)$' \| \
13438          X"$as_dir" : 'X\(/\)' \| \
13439          .     : '\(.\)' 2>/dev/null ||
13440 echo X"$as_dir" |
13441     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13442           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13443           /^X\(\/\/\)$/{ s//\1/; q; }
13444           /^X\(\/\).*/{ s//\1/; q; }
13445           s/.*/./; q'`
13446     done
13447     test ! -n "$as_dirs" || mkdir $as_dirs
13448   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13449 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13450    { (exit 1); exit 1; }; }; }
13451
13452   ac_builddir=.
13453
13454 if test "$ac_dir" != .; then
13455   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13456   # A "../" for each directory in $ac_dir_suffix.
13457   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13458 else
13459   ac_dir_suffix= ac_top_builddir=
13460 fi
13461
13462 case $srcdir in
13463   .)  # No --srcdir option.  We are building in place.
13464     ac_srcdir=.
13465     if test -z "$ac_top_builddir"; then
13466        ac_top_srcdir=.
13467     else
13468        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13469     fi ;;
13470   [\\/]* | ?:[\\/]* )  # Absolute path.
13471     ac_srcdir=$srcdir$ac_dir_suffix;
13472     ac_top_srcdir=$srcdir ;;
13473   *) # Relative path.
13474     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13475     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13476 esac
13477
13478 # Do not use `cd foo && pwd` to compute absolute paths, because
13479 # the directories may not exist.
13480 case `pwd` in
13481 .) ac_abs_builddir="$ac_dir";;
13482 *)
13483   case "$ac_dir" in
13484   .) ac_abs_builddir=`pwd`;;
13485   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13486   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13487   esac;;
13488 esac
13489 case $ac_abs_builddir in
13490 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13491 *)
13492   case ${ac_top_builddir}. in
13493   .) ac_abs_top_builddir=$ac_abs_builddir;;
13494   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13495   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13496   esac;;
13497 esac
13498 case $ac_abs_builddir in
13499 .) ac_abs_srcdir=$ac_srcdir;;
13500 *)
13501   case $ac_srcdir in
13502   .) ac_abs_srcdir=$ac_abs_builddir;;
13503   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13504   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13505   esac;;
13506 esac
13507 case $ac_abs_builddir in
13508 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13509 *)
13510   case $ac_top_srcdir in
13511   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13512   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13513   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13514   esac;;
13515 esac
13516
13517
13518   case $INSTALL in
13519   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13520   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13521   esac
13522
13523   if test x"$ac_file" != x-; then
13524     { echo "$as_me:$LINENO: creating $ac_file" >&5
13525 echo "$as_me: creating $ac_file" >&6;}
13526     rm -f "$ac_file"
13527   fi
13528   # Let's still pretend it is `configure' which instantiates (i.e., don't
13529   # use $as_me), people would be surprised to read:
13530   #    /* config.h.  Generated by config.status.  */
13531   if test x"$ac_file" = x-; then
13532     configure_input=
13533   else
13534     configure_input="$ac_file.  "
13535   fi
13536   configure_input=$configure_input"Generated from `echo $ac_file_in |
13537                                      sed 's,.*/,,'` by configure."
13538
13539   # First look for the input files in the build tree, otherwise in the
13540   # src tree.
13541   ac_file_inputs=`IFS=:
13542     for f in $ac_file_in; do
13543       case $f in
13544       -) echo $tmp/stdin ;;
13545       [\\/$]*)
13546          # Absolute (can't be DOS-style, as IFS=:)
13547          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13548 echo "$as_me: error: cannot find input file: $f" >&2;}
13549    { (exit 1); exit 1; }; }
13550          echo "$f";;
13551       *) # Relative
13552          if test -f "$f"; then
13553            # Build tree
13554            echo "$f"
13555          elif test -f "$srcdir/$f"; then
13556            # Source tree
13557            echo "$srcdir/$f"
13558          else
13559            # /dev/null tree
13560            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13561 echo "$as_me: error: cannot find input file: $f" >&2;}
13562    { (exit 1); exit 1; }; }
13563          fi;;
13564       esac
13565     done` || { (exit 1); exit 1; }
13566 _ACEOF
13567 cat >>$CONFIG_STATUS <<_ACEOF
13568   sed "$ac_vpsub
13569 $extrasub
13570 _ACEOF
13571 cat >>$CONFIG_STATUS <<\_ACEOF
13572 :t
13573 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13574 s,@configure_input@,$configure_input,;t t
13575 s,@srcdir@,$ac_srcdir,;t t
13576 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13577 s,@top_srcdir@,$ac_top_srcdir,;t t
13578 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13579 s,@builddir@,$ac_builddir,;t t
13580 s,@abs_builddir@,$ac_abs_builddir,;t t
13581 s,@top_builddir@,$ac_top_builddir,;t t
13582 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13583 s,@INSTALL@,$ac_INSTALL,;t t
13584 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13585   rm -f $tmp/stdin
13586   if test x"$ac_file" != x-; then
13587     mv $tmp/out $ac_file
13588   else
13589     cat $tmp/out
13590     rm -f $tmp/out
13591   fi
13592
13593 done
13594 _ACEOF
13595
13596 cat >>$CONFIG_STATUS <<\_ACEOF
13597
13598 { (exit 0); exit 0; }
13599 _ACEOF
13600 chmod +x $CONFIG_STATUS
13601 ac_clean_files=$ac_clean_files_save
13602
13603
13604 # configure is writing to config.log, and then calls config.status.
13605 # config.status does its own redirection, appending to config.log.
13606 # Unfortunately, on DOS this fails, as config.log is still kept open
13607 # by configure, so config.status won't be able to write to it; its
13608 # output is simply discarded.  So we exec the FD to /dev/null,
13609 # effectively closing config.log, so it can be properly (re)opened and
13610 # appended to by config.status.  When coming back to configure, we
13611 # need to make the FD available again.
13612 if test "$no_create" != yes; then
13613   ac_cs_success=:
13614   ac_config_status_args=
13615   test "$silent" = yes &&
13616     ac_config_status_args="$ac_config_status_args --quiet"
13617   exec 5>/dev/null
13618   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13619   exec 5>>config.log
13620   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13621   # would make configure fail if this is the last instruction.
13622   $ac_cs_success || { (exit 1); exit 1; }
13623 fi
13624