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 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   moxie-*-*)
2413     noconfigdirs="$noconfigdirs ${libgcj}"
2414     noconfigdirs="$noconfigdirs gprof"
2415     ;;
2416   h8300*-*-*)
2417     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2418     ;;
2419   h8500-*-*)
2420     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2421     ;;
2422   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2423     ;;
2424   hppa*64*-*-linux* | parisc*64*-*-linux*)
2425     # In this case, it's because the hppa64-linux target is for
2426     # the kernel only at this point and has no libc, and thus no
2427     # headers, crt*.o, etc., all of which are needed by these.
2428     noconfigdirs="$noconfigdirs target-zlib"
2429     ;;
2430   parisc*-*-linux* | hppa*-*-linux*)
2431     ;;
2432   hppa*-*-*elf* | \
2433   hppa*-*-lites* | \
2434   hppa*-*-openbsd* | \
2435   hppa*64*-*-*)
2436     noconfigdirs="$noconfigdirs ${libgcj}"
2437     ;;
2438   hppa*-hp-hpux11*)
2439     noconfigdirs="$noconfigdirs ld shellutils"
2440     ;;
2441   hppa*-*-pro*)
2442     libgloss_dir=pa
2443     ;;
2444   hppa*-*-*)
2445     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2446     # build on HP-UX 10.20.
2447     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2448     ;;
2449   i960-*-*)
2450     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2451     ;;
2452   ia64*-*-elf*)
2453     # No gdb support yet.
2454     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2455     ;;
2456   ia64*-**-hpux*)
2457     # No gdb or ld support yet.
2458     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2459     ;;
2460   ia64*-*-*vms*)
2461     # No gdb or ld support yet.
2462     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2463     ;;
2464   i370-*-opened*)
2465     ;;
2466   i[3456789]86-*-coff | i[3456789]86-*-elf)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     libgloss_dir=i386
2469     ;;
2470   i[3456789]86-*-linux*)
2471     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2472     # not build java stuff by default.
2473     case "${target}" in
2474       *-*-*libc1*)
2475         noconfigdirs="$noconfigdirs ${libgcj}";;
2476     esac
2477
2478     # This section makes it possible to build newlib natively on linux.
2479     # If we are using a cross compiler then don't configure newlib.
2480     if test x${is_cross_compiler} != xno ; then
2481       noconfigdirs="$noconfigdirs target-newlib"
2482     fi
2483     noconfigdirs="$noconfigdirs target-libgloss"
2484     # If we are not using a cross compiler, do configure newlib.
2485     # Note however, that newlib will only be configured in this situation
2486     # if the --with-newlib option has been given, because otherwise
2487     # 'target-newlib' will appear in skipdirs.
2488     ;;
2489   i[3456789]86-*-mingw32*)
2490     target_configdirs="$target_configdirs target-winsup"
2491     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2492     ;;
2493   x86_64-*-mingw*)
2494     target_configdirs="$target_configdirs target-winsup"
2495     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2496     ;;
2497   *-*-cygwin*)
2498     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2499     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2500     # always build newlib if winsup directory is present.
2501     if test -d "$srcdir/winsup/cygwin"; then
2502       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2503     elif test -d "$srcdir/newlib"; then
2504       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2505     fi
2506     ;;
2507   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2508   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2509     ;;
2510   i[3456789]86-*-pe)
2511     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2512     ;;
2513   i[3456789]86-*-sco3.2v5*)
2514     # The linker does not yet know about weak symbols in COFF,
2515     # and is not configured to handle mixed ELF and COFF.
2516     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2517     ;;
2518   i[3456789]86-*-sco*)
2519     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2520     ;;
2521   i[3456789]86-*-solaris2*)
2522     noconfigdirs="$noconfigdirs target-libgloss"
2523     ;;
2524   i[3456789]86-*-sysv4*)
2525     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2526     ;;
2527   i[3456789]86-*-beos*)
2528     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2529     ;;
2530   i[3456789]86-*-rdos*)
2531     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2532     ;;
2533   m32r-*-*)
2534     noconfigdirs="$noconfigdirs ${libgcj}"
2535     ;;
2536   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2537     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2538     libgloss_dir=m68hc11
2539     ;;
2540   m68k-*-elf*)
2541     noconfigdirs="$noconfigdirs ${libgcj}"
2542     ;;
2543   m68k-*-coff*)
2544     noconfigdirs="$noconfigdirs ${libgcj}"
2545     ;;
2546   m68*-*-* | fido-*-*)
2547     libgloss_dir=m68k
2548     ;;
2549   mcore-*-pe*)
2550   # The EPOC C++ environment does not support exceptions or rtti,
2551   # and so building libstdc++-v3 tends not to always work.
2552     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2553     ;;
2554   mmix-*-*)
2555     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2556     unsupported_languages="$unsupported_languages fortran java"
2557     ;;
2558   mn10200-*-*)
2559     noconfigdirs="$noconfigdirs ${libgcj}"
2560     ;;
2561   mn10300-*-*)
2562     noconfigdirs="$noconfigdirs ${libgcj}"
2563     ;;
2564   mt-*-*)
2565     noconfigdirs="$noconfigdirs sim"
2566     ;;
2567   powerpc-*-aix*)
2568     # copied from rs6000-*-* entry
2569     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2570     ;;
2571   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2572     target_configdirs="$target_configdirs target-winsup"
2573     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2574     # always build newlib.
2575     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2576     ;;
2577     # This is temporary until we can link against shared libraries
2578   powerpcle-*-solaris*)
2579     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2580     libgloss_dir=rs6000
2581     ;;
2582   powerpc-*-beos*)
2583     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2584     ;;
2585   powerpc-*-eabi)
2586     noconfigdirs="$noconfigdirs ${libgcj}"
2587     libgloss_dir=rs6000
2588     ;;
2589   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2590     libgloss_dir=rs6000
2591     ;;
2592   rs6000-*-lynxos*)
2593     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2594     ;;
2595   rs6000-*-aix*)
2596     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2597     ;;
2598   rs6000-*-*)
2599     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2600     ;;
2601   m68k-apollo-*)
2602     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2603     ;;
2604   mips*-sde-elf*)
2605     skipdirs="$skipdirs target-libiberty"
2606     noconfigdirs="$noconfigdirs ${libgcj}"
2607     if test x$with_newlib = xyes; then
2608       noconfigdirs="$noconfigdirs gprof"
2609     fi
2610     libgloss_dir=mips
2611     ;;
2612   mips*-*-irix5*)
2613     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2614     ;;
2615   mips*-*-irix6*)
2616     # Linking libjava exceeds command-line length limits on at least
2617     # IRIX 6.2, but not on IRIX 6.5.
2618     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2619     # <oldham@codesourcery.com>
2620     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2621     ;;
2622   mips*-*-bsd*)
2623     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2624     ;;
2625   mips*-*-linux*)
2626     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2627     ;;
2628   mips*-*-*)
2629     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2630     libgloss_dir=mips
2631     ;;
2632   romp-*-*)
2633     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2634     ;;
2635   sh-*-* | sh64-*-*)
2636     case "${host}" in
2637       i[3456789]86-*-vsta) ;; # don't add gprof back in
2638       i[3456789]86-*-go32*) ;; # don't add gprof back in
2639       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2640       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2641     esac
2642     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2643     ;;
2644   sparclet-*-aout* | sparc86x-*-*)
2645     libgloss_dir=sparc
2646     ;;
2647   sparc-*-elf*)
2648     noconfigdirs="$noconfigdirs ${libgcj}"
2649     ;;
2650   sparc64-*-elf*)
2651     noconfigdirs="$noconfigdirs ${libgcj}"
2652     libgloss_dir=sparc
2653     ;;
2654   sparclite-*-*)
2655     noconfigdirs="$noconfigdirs ${libgcj}"
2656     libgloss_dir=sparc
2657     ;;
2658   sparc-*-sunos4*)
2659     noconfigdirs="$noconfigdirs ${libgcj}"
2660     if test x${is_cross_compiler} != xno ; then
2661            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2662     else
2663            use_gnu_ld=no
2664     fi
2665     ;;
2666   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2667     noconfigdirs="$noconfigdirs ${libgcj}"
2668     ;;
2669   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2670     ;;
2671   v810-*-*)
2672     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2673     ;;
2674   v850-*-*)
2675     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2676     ;;
2677   v850e-*-*)
2678     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2679     ;;
2680   v850ea-*-*)
2681     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2682     ;;
2683   vax-*-vms)
2684     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2685     ;;
2686   vax-*-*)
2687     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2688     ;;
2689   xtensa*-*-*)
2690     noconfigdirs="$noconfigdirs ${libgcj}"
2691     ;;
2692   ip2k-*-*)
2693     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2694     ;;
2695   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2696     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2697     ;;
2698   *-*-lynxos*)
2699     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2700     ;;
2701   *-*-*)
2702     noconfigdirs="$noconfigdirs ${libgcj}"
2703     ;;
2704 esac
2705
2706 # If we aren't building newlib, then don't build libgloss, since libgloss
2707 # depends upon some newlib header files.
2708 case "${noconfigdirs}" in
2709   *target-libgloss*) ;;
2710   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2711 esac
2712
2713 # Work in distributions that contain no compiler tools, like Autoconf.
2714 tentative_cc=""
2715 host_makefile_frag=/dev/null
2716 if test -d ${srcdir}/config ; then
2717 case "${host}" in
2718   m68k-hp-hpux*)
2719     # Avoid "too much defining" errors from HPUX compiler.
2720     tentative_cc="cc -Wp,-H256000"
2721     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2722     # If it's HP/UX ar, this should be harmless.
2723     RANLIB="ar ts"
2724     ;;
2725   m68k-apollo-sysv*)
2726     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2727     ;;
2728   m68k-apollo-bsd*)
2729     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2730     # chokes on bfd, the compiler won't let you assign integers to enums, and
2731     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2732     # the apollo compiler" (the preferred version of GCC could be called cc,
2733     # or whatever), but I'm not sure leaving CC as cc is any better...
2734     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2735     # Used to have BISON=yacc.
2736     tentative_cc=gcc
2737     ;;
2738   m88k-dg-dgux*)
2739     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2740     ;;
2741   m88k-harris-cxux*)
2742     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2743     tentative_cc="cc -Xa"
2744     host_makefile_frag="config/mh-cxux"
2745     ;;
2746   m88k-motorola-sysv*)
2747     ;;
2748   mips*-dec-ultrix*)
2749     tentative_cc="cc -Wf,-XNg1000"
2750     host_makefile_frag="config/mh-decstation"
2751     ;;
2752   mips*-nec-sysv4*)
2753     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2754     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2755     host_makefile_frag="config/mh-necv4"
2756     ;;
2757   mips*-sgi-irix4*)
2758     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2759     # environment.  Also bump switch table size so that cp-parse will
2760     # compile.  Bump string length limit so linker builds.
2761     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2762     ;;
2763   mips*-*-sysv4*)
2764     host_makefile_frag="config/mh-sysv4"
2765     ;;
2766   mips*-*-sysv*)
2767     # This is for a MIPS running RISC/os 4.52C.
2768
2769     # This is needed for GDB, but needs to be in the top-level make because
2770     # if a library is compiled with the bsd headers and gets linked with the
2771     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2772     # a different size).
2773     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2774     # known except to select the sysv environment.  Could we use /proc instead?
2775     # These "sysv environments" and "bsd environments" often end up being a pain.
2776     #
2777     # This is not part of CFLAGS because perhaps not all C compilers have this
2778     # option.
2779     tentative_cc="cc -systype sysv"
2780     ;;
2781   i370-ibm-opened*)
2782     tentative_cc="c89"
2783     ;;
2784   i[3456789]86-*-sysv5*)
2785     host_makefile_frag="config/mh-sysv5"
2786     ;;
2787   i[3456789]86-*-dgux*)
2788     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2789     host_makefile_frag="config/mh-dgux386"
2790     ;;
2791   i[3456789]86-ncr-sysv4.3*)
2792     # The MetaWare compiler will generate a copyright message unless you
2793     # turn it off by adding the -Hnocopyr flag.
2794     tentative_cc="cc -Hnocopyr"
2795     ;;
2796   i[3456789]86-ncr-sysv4*)
2797     # for an NCR 3000 (i486/SVR4) system.
2798     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2799     # This compiler not only emits obnoxious copyright messages every time
2800     # you run it, but it chokes and dies on a whole bunch of GNU source
2801     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2802     tentative_cc="/usr/ccs/ATT/cc"
2803     host_makefile_frag="config/mh-ncr3000"
2804     ;;
2805   i[3456789]86-*-sco3.2v5*)
2806     ;;
2807   i[3456789]86-*-sco*)
2808     # The native C compiler botches some simple uses of const.  Unfortunately,
2809     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2810     tentative_cc="cc -Dconst="
2811     host_makefile_frag="config/mh-sco"
2812     ;;
2813   i[3456789]86-*-udk*)
2814     host_makefile_frag="config/mh-sysv5"
2815     ;;
2816   i[3456789]86-*-solaris2*)
2817     host_makefile_frag="config/mh-sysv4"
2818     ;;
2819   i[3456789]86-*-msdosdjgpp*)
2820     host_makefile_frag="config/mh-djgpp"
2821     ;;
2822   *-cygwin*)
2823
2824 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2825 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2826 echo a >cygwin-cat-check
2827 if test `cat cygwin-cat-check` == a ; then
2828   rm cygwin-cat-check
2829   echo "$as_me:$LINENO: result: yes" >&5
2830 echo "${ECHO_T}yes" >&6
2831 else
2832   rm cygwin-cat-check
2833   echo "$as_me:$LINENO: result: no" >&5
2834 echo "${ECHO_T}no" >&6
2835   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2836   Please either mount the build directory in binary mode or run the following
2837   commands before running any configure script:
2838 set -o igncr
2839 export SHELLOPTS
2840   " >&5
2841 echo "$as_me: error: The cat command does not ignore carriage return characters.
2842   Please either mount the build directory in binary mode or run the following
2843   commands before running any configure script:
2844 set -o igncr
2845 export SHELLOPTS
2846   " >&2;}
2847    { (exit 1); exit 1; }; }
2848 fi
2849
2850     host_makefile_frag="config/mh-cygwin"
2851     ;;
2852   *-mingw*)
2853     host_makefile_frag="config/mh-mingw"
2854     ;;
2855   *-interix*)
2856     host_makefile_frag="config/mh-interix"
2857     ;;
2858   vax-*-ultrix2*)
2859     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2860     tentative_cc=gcc
2861     ;;
2862   *-*-solaris2*)
2863     host_makefile_frag="config/mh-solaris"
2864     ;;
2865   m68k-sun-sunos*)
2866     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2867     # without overflowing the jump tables (-J says to use a 32 bit table)
2868     tentative_cc="cc -J"
2869     ;;
2870   hppa*-hp-hpux10*)
2871     tentative_cc="cc -Wp,-H256000"
2872     host_makefile_frag="config/mh-pa-hpux10"
2873     ;;
2874   hppa*-hp-hpux* | hppa*-*-hiux*)
2875     tentative_cc="cc -Wp,-H256000"
2876     host_makefile_frag="config/mh-pa"
2877     ;;
2878   hppa*-*)
2879     host_makefile_frag="config/mh-pa"
2880     ;;
2881   *-hp-hpux* | *-*-hiux*)
2882     tentative_cc="cc -Wp,-H256000"
2883     ;;
2884   rs6000-*-lynxos*)
2885     # /bin/cc is less than useful for our purposes.  Always use GCC
2886     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2887     host_makefile_frag="config/mh-lynxrs6k"
2888     ;;
2889   powerpc-*-darwin*)
2890     host_makefile_frag="config/mh-ppc-darwin"
2891     ;;
2892   powerpc-*-aix*)
2893     host_makefile_frag="config/mh-ppc-aix"
2894     ;;
2895   rs6000-*-aix*)
2896     host_makefile_frag="config/mh-ppc-aix"
2897     ;;
2898   *-*-lynxos*)
2899     # /bin/cc is less than useful for our purposes.  Always use GCC
2900     tentative_cc="/bin/gcc"
2901     ;;
2902   *-*-sysv4*)
2903     host_makefile_frag="config/mh-sysv4"
2904     ;;
2905   # This is placed last to prevent interfering with the cases above.
2906   i[3456789]86-*-*)
2907     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2908     host_makefile_frag="config/mh-x86omitfp"
2909     ;;
2910 esac
2911 fi
2912
2913 # If we aren't going to be using gcc, see if we can extract a definition
2914 # of CC from the fragment.
2915 # Actually, use the 'pre-extracted' version above.
2916 if test -z "${CC}" && test "${build}" = "${host}" ; then
2917   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2918   found=
2919   for dir in $PATH; do
2920     test -z "$dir" && dir=.
2921     if test -f $dir/gcc; then
2922       found=yes
2923       break
2924     fi
2925   done
2926   IFS="$save_ifs"
2927   if test -z "${found}" && test -n "${tentative_cc}" ; then
2928     CC=$tentative_cc
2929   fi
2930 fi
2931
2932 if test "${build}" != "${host}" ; then
2933   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2934   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2935   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2936   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2937   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2938   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2939   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2940   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2941   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2942   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2943   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2944   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2945 else
2946   AR_FOR_BUILD="\$(AR)"
2947   AS_FOR_BUILD="\$(AS)"
2948   CC_FOR_BUILD="\$(CC)"
2949   CXX_FOR_BUILD="\$(CXX)"
2950   GCJ_FOR_BUILD="\$(GCJ)"
2951   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2952   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2953   LD_FOR_BUILD="\$(LD)"
2954   NM_FOR_BUILD="\$(NM)"
2955   RANLIB_FOR_BUILD="\$(RANLIB)"
2956   WINDRES_FOR_BUILD="\$(WINDRES)"
2957   WINDMC_FOR_BUILD="\$(WINDMC)"
2958 fi
2959
2960 ac_ext=c
2961 ac_cpp='$CPP $CPPFLAGS'
2962 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2963 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2964 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2965 if test -n "$ac_tool_prefix"; then
2966   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2967 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2968 echo "$as_me:$LINENO: checking for $ac_word" >&5
2969 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2970 if test "${ac_cv_prog_CC+set}" = set; then
2971   echo $ECHO_N "(cached) $ECHO_C" >&6
2972 else
2973   if test -n "$CC"; then
2974   ac_cv_prog_CC="$CC" # Let the user override the test.
2975 else
2976 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2977 for as_dir in $PATH
2978 do
2979   IFS=$as_save_IFS
2980   test -z "$as_dir" && as_dir=.
2981   for ac_exec_ext in '' $ac_executable_extensions; do
2982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2983     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2985     break 2
2986   fi
2987 done
2988 done
2989
2990 fi
2991 fi
2992 CC=$ac_cv_prog_CC
2993 if test -n "$CC"; then
2994   echo "$as_me:$LINENO: result: $CC" >&5
2995 echo "${ECHO_T}$CC" >&6
2996 else
2997   echo "$as_me:$LINENO: result: no" >&5
2998 echo "${ECHO_T}no" >&6
2999 fi
3000
3001 fi
3002 if test -z "$ac_cv_prog_CC"; then
3003   ac_ct_CC=$CC
3004   # Extract the first word of "gcc", so it can be a program name with args.
3005 set dummy gcc; ac_word=$2
3006 echo "$as_me:$LINENO: checking for $ac_word" >&5
3007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3008 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3009   echo $ECHO_N "(cached) $ECHO_C" >&6
3010 else
3011   if test -n "$ac_ct_CC"; then
3012   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3013 else
3014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3015 for as_dir in $PATH
3016 do
3017   IFS=$as_save_IFS
3018   test -z "$as_dir" && as_dir=.
3019   for ac_exec_ext in '' $ac_executable_extensions; do
3020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3021     ac_cv_prog_ac_ct_CC="gcc"
3022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3023     break 2
3024   fi
3025 done
3026 done
3027
3028 fi
3029 fi
3030 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3031 if test -n "$ac_ct_CC"; then
3032   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3033 echo "${ECHO_T}$ac_ct_CC" >&6
3034 else
3035   echo "$as_me:$LINENO: result: no" >&5
3036 echo "${ECHO_T}no" >&6
3037 fi
3038
3039   CC=$ac_ct_CC
3040 else
3041   CC="$ac_cv_prog_CC"
3042 fi
3043
3044 if test -z "$CC"; then
3045   if test -n "$ac_tool_prefix"; then
3046   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3047 set dummy ${ac_tool_prefix}cc; ac_word=$2
3048 echo "$as_me:$LINENO: checking for $ac_word" >&5
3049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3050 if test "${ac_cv_prog_CC+set}" = set; then
3051   echo $ECHO_N "(cached) $ECHO_C" >&6
3052 else
3053   if test -n "$CC"; then
3054   ac_cv_prog_CC="$CC" # Let the user override the test.
3055 else
3056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3057 for as_dir in $PATH
3058 do
3059   IFS=$as_save_IFS
3060   test -z "$as_dir" && as_dir=.
3061   for ac_exec_ext in '' $ac_executable_extensions; do
3062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3063     ac_cv_prog_CC="${ac_tool_prefix}cc"
3064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3065     break 2
3066   fi
3067 done
3068 done
3069
3070 fi
3071 fi
3072 CC=$ac_cv_prog_CC
3073 if test -n "$CC"; then
3074   echo "$as_me:$LINENO: result: $CC" >&5
3075 echo "${ECHO_T}$CC" >&6
3076 else
3077   echo "$as_me:$LINENO: result: no" >&5
3078 echo "${ECHO_T}no" >&6
3079 fi
3080
3081 fi
3082 if test -z "$ac_cv_prog_CC"; then
3083   ac_ct_CC=$CC
3084   # Extract the first word of "cc", so it can be a program name with args.
3085 set dummy cc; ac_word=$2
3086 echo "$as_me:$LINENO: checking for $ac_word" >&5
3087 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3088 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3089   echo $ECHO_N "(cached) $ECHO_C" >&6
3090 else
3091   if test -n "$ac_ct_CC"; then
3092   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3093 else
3094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3095 for as_dir in $PATH
3096 do
3097   IFS=$as_save_IFS
3098   test -z "$as_dir" && as_dir=.
3099   for ac_exec_ext in '' $ac_executable_extensions; do
3100   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3101     ac_cv_prog_ac_ct_CC="cc"
3102     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3103     break 2
3104   fi
3105 done
3106 done
3107
3108 fi
3109 fi
3110 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3111 if test -n "$ac_ct_CC"; then
3112   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3113 echo "${ECHO_T}$ac_ct_CC" >&6
3114 else
3115   echo "$as_me:$LINENO: result: no" >&5
3116 echo "${ECHO_T}no" >&6
3117 fi
3118
3119   CC=$ac_ct_CC
3120 else
3121   CC="$ac_cv_prog_CC"
3122 fi
3123
3124 fi
3125 if test -z "$CC"; then
3126   # Extract the first word of "cc", so it can be a program name with args.
3127 set dummy cc; ac_word=$2
3128 echo "$as_me:$LINENO: checking for $ac_word" >&5
3129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3130 if test "${ac_cv_prog_CC+set}" = set; then
3131   echo $ECHO_N "(cached) $ECHO_C" >&6
3132 else
3133   if test -n "$CC"; then
3134   ac_cv_prog_CC="$CC" # Let the user override the test.
3135 else
3136   ac_prog_rejected=no
3137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3138 for as_dir in $PATH
3139 do
3140   IFS=$as_save_IFS
3141   test -z "$as_dir" && as_dir=.
3142   for ac_exec_ext in '' $ac_executable_extensions; do
3143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3144     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3145        ac_prog_rejected=yes
3146        continue
3147      fi
3148     ac_cv_prog_CC="cc"
3149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3150     break 2
3151   fi
3152 done
3153 done
3154
3155 if test $ac_prog_rejected = yes; then
3156   # We found a bogon in the path, so make sure we never use it.
3157   set dummy $ac_cv_prog_CC
3158   shift
3159   if test $# != 0; then
3160     # We chose a different compiler from the bogus one.
3161     # However, it has the same basename, so the bogon will be chosen
3162     # first if we set CC to just the basename; use the full file name.
3163     shift
3164     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3165   fi
3166 fi
3167 fi
3168 fi
3169 CC=$ac_cv_prog_CC
3170 if test -n "$CC"; then
3171   echo "$as_me:$LINENO: result: $CC" >&5
3172 echo "${ECHO_T}$CC" >&6
3173 else
3174   echo "$as_me:$LINENO: result: no" >&5
3175 echo "${ECHO_T}no" >&6
3176 fi
3177
3178 fi
3179 if test -z "$CC"; then
3180   if test -n "$ac_tool_prefix"; then
3181   for ac_prog in cl
3182   do
3183     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3184 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3185 echo "$as_me:$LINENO: checking for $ac_word" >&5
3186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3187 if test "${ac_cv_prog_CC+set}" = set; then
3188   echo $ECHO_N "(cached) $ECHO_C" >&6
3189 else
3190   if test -n "$CC"; then
3191   ac_cv_prog_CC="$CC" # Let the user override the test.
3192 else
3193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3194 for as_dir in $PATH
3195 do
3196   IFS=$as_save_IFS
3197   test -z "$as_dir" && as_dir=.
3198   for ac_exec_ext in '' $ac_executable_extensions; do
3199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3200     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3202     break 2
3203   fi
3204 done
3205 done
3206
3207 fi
3208 fi
3209 CC=$ac_cv_prog_CC
3210 if test -n "$CC"; then
3211   echo "$as_me:$LINENO: result: $CC" >&5
3212 echo "${ECHO_T}$CC" >&6
3213 else
3214   echo "$as_me:$LINENO: result: no" >&5
3215 echo "${ECHO_T}no" >&6
3216 fi
3217
3218     test -n "$CC" && break
3219   done
3220 fi
3221 if test -z "$CC"; then
3222   ac_ct_CC=$CC
3223   for ac_prog in cl
3224 do
3225   # Extract the first word of "$ac_prog", so it can be a program name with args.
3226 set dummy $ac_prog; ac_word=$2
3227 echo "$as_me:$LINENO: checking for $ac_word" >&5
3228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3229 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3230   echo $ECHO_N "(cached) $ECHO_C" >&6
3231 else
3232   if test -n "$ac_ct_CC"; then
3233   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3234 else
3235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3236 for as_dir in $PATH
3237 do
3238   IFS=$as_save_IFS
3239   test -z "$as_dir" && as_dir=.
3240   for ac_exec_ext in '' $ac_executable_extensions; do
3241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3242     ac_cv_prog_ac_ct_CC="$ac_prog"
3243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3244     break 2
3245   fi
3246 done
3247 done
3248
3249 fi
3250 fi
3251 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3252 if test -n "$ac_ct_CC"; then
3253   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3254 echo "${ECHO_T}$ac_ct_CC" >&6
3255 else
3256   echo "$as_me:$LINENO: result: no" >&5
3257 echo "${ECHO_T}no" >&6
3258 fi
3259
3260   test -n "$ac_ct_CC" && break
3261 done
3262
3263   CC=$ac_ct_CC
3264 fi
3265
3266 fi
3267
3268
3269 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3270 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3271 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3272 See \`config.log' for more details." >&5
3273 echo "$as_me: error: no acceptable C compiler found in \$PATH
3274 See \`config.log' for more details." >&2;}
3275    { (exit 1); exit 1; }; }; }
3276
3277 # Provide some information about the compiler.
3278 echo "$as_me:$LINENO:" \
3279      "checking for C compiler version" >&5
3280 ac_compiler=`set X $ac_compile; echo $2`
3281 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3282   (eval $ac_compiler --version </dev/null >&5) 2>&5
3283   ac_status=$?
3284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3285   (exit $ac_status); }
3286 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3287   (eval $ac_compiler -v </dev/null >&5) 2>&5
3288   ac_status=$?
3289   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3290   (exit $ac_status); }
3291 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3292   (eval $ac_compiler -V </dev/null >&5) 2>&5
3293   ac_status=$?
3294   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3295   (exit $ac_status); }
3296
3297 cat >conftest.$ac_ext <<_ACEOF
3298 /* confdefs.h.  */
3299 _ACEOF
3300 cat confdefs.h >>conftest.$ac_ext
3301 cat >>conftest.$ac_ext <<_ACEOF
3302 /* end confdefs.h.  */
3303
3304 int
3305 main ()
3306 {
3307
3308   ;
3309   return 0;
3310 }
3311 _ACEOF
3312 ac_clean_files_save=$ac_clean_files
3313 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3314 # Try to create an executable without -o first, disregard a.out.
3315 # It will help us diagnose broken compilers, and finding out an intuition
3316 # of exeext.
3317 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3318 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3319 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3320 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3321   (eval $ac_link_default) 2>&5
3322   ac_status=$?
3323   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3324   (exit $ac_status); }; then
3325   # Find the output, starting from the most likely.  This scheme is
3326 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3327 # resort.
3328
3329 # Be careful to initialize this variable, since it used to be cached.
3330 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3331 ac_cv_exeext=
3332 # b.out is created by i960 compilers.
3333 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3334 do
3335   test -f "$ac_file" || continue
3336   case $ac_file in
3337     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3338         ;;
3339     conftest.$ac_ext )
3340         # This is the source file.
3341         ;;
3342     [ab].out )
3343         # We found the default executable, but exeext='' is most
3344         # certainly right.
3345         break;;
3346     *.* )
3347         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3348         # FIXME: I believe we export ac_cv_exeext for Libtool,
3349         # but it would be cool to find out if it's true.  Does anybody
3350         # maintain Libtool? --akim.
3351         export ac_cv_exeext
3352         break;;
3353     * )
3354         break;;
3355   esac
3356 done
3357 else
3358   echo "$as_me: failed program was:" >&5
3359 sed 's/^/| /' conftest.$ac_ext >&5
3360
3361 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3362 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3363 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3364 See \`config.log' for more details." >&5
3365 echo "$as_me: error: C compiler cannot create executables
3366 See \`config.log' for more details." >&2;}
3367    { (exit 77); exit 77; }; }; }
3368 fi
3369
3370 ac_exeext=$ac_cv_exeext
3371 echo "$as_me:$LINENO: result: $ac_file" >&5
3372 echo "${ECHO_T}$ac_file" >&6
3373
3374 # Check the compiler produces executables we can run.  If not, either
3375 # the compiler is broken, or we cross compile.
3376 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3377 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3378 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3379 # If not cross compiling, check that we can run a simple program.
3380 if test "$cross_compiling" != yes; then
3381   if { ac_try='./$ac_file'
3382   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3383   (eval $ac_try) 2>&5
3384   ac_status=$?
3385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3386   (exit $ac_status); }; }; then
3387     cross_compiling=no
3388   else
3389     if test "$cross_compiling" = maybe; then
3390         cross_compiling=yes
3391     else
3392         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3393 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3394 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3395 If you meant to cross compile, use \`--host'.
3396 See \`config.log' for more details." >&5
3397 echo "$as_me: error: cannot run C compiled programs.
3398 If you meant to cross compile, use \`--host'.
3399 See \`config.log' for more details." >&2;}
3400    { (exit 1); exit 1; }; }; }
3401     fi
3402   fi
3403 fi
3404 echo "$as_me:$LINENO: result: yes" >&5
3405 echo "${ECHO_T}yes" >&6
3406
3407 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3408 ac_clean_files=$ac_clean_files_save
3409 # Check the compiler produces executables we can run.  If not, either
3410 # the compiler is broken, or we cross compile.
3411 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3412 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3413 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3414 echo "${ECHO_T}$cross_compiling" >&6
3415
3416 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3417 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3418 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3419   (eval $ac_link) 2>&5
3420   ac_status=$?
3421   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3422   (exit $ac_status); }; then
3423   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3424 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3425 # work properly (i.e., refer to `conftest.exe'), while it won't with
3426 # `rm'.
3427 for ac_file in conftest.exe conftest conftest.*; do
3428   test -f "$ac_file" || continue
3429   case $ac_file in
3430     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3431     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3432           export ac_cv_exeext
3433           break;;
3434     * ) break;;
3435   esac
3436 done
3437 else
3438   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3439 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3440 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3441 See \`config.log' for more details." >&5
3442 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3443 See \`config.log' for more details." >&2;}
3444    { (exit 1); exit 1; }; }; }
3445 fi
3446
3447 rm -f conftest$ac_cv_exeext
3448 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3449 echo "${ECHO_T}$ac_cv_exeext" >&6
3450
3451 rm -f conftest.$ac_ext
3452 EXEEXT=$ac_cv_exeext
3453 ac_exeext=$EXEEXT
3454 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3455 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3456 if test "${ac_cv_objext+set}" = set; then
3457   echo $ECHO_N "(cached) $ECHO_C" >&6
3458 else
3459   cat >conftest.$ac_ext <<_ACEOF
3460 /* confdefs.h.  */
3461 _ACEOF
3462 cat confdefs.h >>conftest.$ac_ext
3463 cat >>conftest.$ac_ext <<_ACEOF
3464 /* end confdefs.h.  */
3465
3466 int
3467 main ()
3468 {
3469
3470   ;
3471   return 0;
3472 }
3473 _ACEOF
3474 rm -f conftest.o conftest.obj
3475 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3476   (eval $ac_compile) 2>&5
3477   ac_status=$?
3478   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3479   (exit $ac_status); }; then
3480   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3481   case $ac_file in
3482     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3483     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3484        break;;
3485   esac
3486 done
3487 else
3488   echo "$as_me: failed program was:" >&5
3489 sed 's/^/| /' conftest.$ac_ext >&5
3490
3491 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3492 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3493 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3494 See \`config.log' for more details." >&5
3495 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3496 See \`config.log' for more details." >&2;}
3497    { (exit 1); exit 1; }; }; }
3498 fi
3499
3500 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3501 fi
3502 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3503 echo "${ECHO_T}$ac_cv_objext" >&6
3504 OBJEXT=$ac_cv_objext
3505 ac_objext=$OBJEXT
3506 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3507 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3508 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3509   echo $ECHO_N "(cached) $ECHO_C" >&6
3510 else
3511   cat >conftest.$ac_ext <<_ACEOF
3512 /* confdefs.h.  */
3513 _ACEOF
3514 cat confdefs.h >>conftest.$ac_ext
3515 cat >>conftest.$ac_ext <<_ACEOF
3516 /* end confdefs.h.  */
3517
3518 int
3519 main ()
3520 {
3521 #ifndef __GNUC__
3522        choke me
3523 #endif
3524
3525   ;
3526   return 0;
3527 }
3528 _ACEOF
3529 rm -f conftest.$ac_objext
3530 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3531   (eval $ac_compile) 2>conftest.er1
3532   ac_status=$?
3533   grep -v '^ *+' conftest.er1 >conftest.err
3534   rm -f conftest.er1
3535   cat conftest.err >&5
3536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3537   (exit $ac_status); } &&
3538          { ac_try='test -z "$ac_c_werror_flag"
3539                          || test ! -s conftest.err'
3540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3541   (eval $ac_try) 2>&5
3542   ac_status=$?
3543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3544   (exit $ac_status); }; } &&
3545          { ac_try='test -s conftest.$ac_objext'
3546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3547   (eval $ac_try) 2>&5
3548   ac_status=$?
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); }; }; then
3551   ac_compiler_gnu=yes
3552 else
3553   echo "$as_me: failed program was:" >&5
3554 sed 's/^/| /' conftest.$ac_ext >&5
3555
3556 ac_compiler_gnu=no
3557 fi
3558 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3559 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3560
3561 fi
3562 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3563 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3564 GCC=`test $ac_compiler_gnu = yes && echo yes`
3565 ac_test_CFLAGS=${CFLAGS+set}
3566 ac_save_CFLAGS=$CFLAGS
3567 CFLAGS="-g"
3568 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3569 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3570 if test "${ac_cv_prog_cc_g+set}" = set; then
3571   echo $ECHO_N "(cached) $ECHO_C" >&6
3572 else
3573   cat >conftest.$ac_ext <<_ACEOF
3574 /* confdefs.h.  */
3575 _ACEOF
3576 cat confdefs.h >>conftest.$ac_ext
3577 cat >>conftest.$ac_ext <<_ACEOF
3578 /* end confdefs.h.  */
3579
3580 int
3581 main ()
3582 {
3583
3584   ;
3585   return 0;
3586 }
3587 _ACEOF
3588 rm -f conftest.$ac_objext
3589 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3590   (eval $ac_compile) 2>conftest.er1
3591   ac_status=$?
3592   grep -v '^ *+' conftest.er1 >conftest.err
3593   rm -f conftest.er1
3594   cat conftest.err >&5
3595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3596   (exit $ac_status); } &&
3597          { ac_try='test -z "$ac_c_werror_flag"
3598                          || test ! -s conftest.err'
3599   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3600   (eval $ac_try) 2>&5
3601   ac_status=$?
3602   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3603   (exit $ac_status); }; } &&
3604          { ac_try='test -s conftest.$ac_objext'
3605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3606   (eval $ac_try) 2>&5
3607   ac_status=$?
3608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3609   (exit $ac_status); }; }; then
3610   ac_cv_prog_cc_g=yes
3611 else
3612   echo "$as_me: failed program was:" >&5
3613 sed 's/^/| /' conftest.$ac_ext >&5
3614
3615 ac_cv_prog_cc_g=no
3616 fi
3617 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3618 fi
3619 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3620 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3621 if test "$ac_test_CFLAGS" = set; then
3622   CFLAGS=$ac_save_CFLAGS
3623 elif test $ac_cv_prog_cc_g = yes; then
3624   if test "$GCC" = yes; then
3625     CFLAGS="-g -O2"
3626   else
3627     CFLAGS="-g"
3628   fi
3629 else
3630   if test "$GCC" = yes; then
3631     CFLAGS="-O2"
3632   else
3633     CFLAGS=
3634   fi
3635 fi
3636 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3637 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3638 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3639   echo $ECHO_N "(cached) $ECHO_C" >&6
3640 else
3641   ac_cv_prog_cc_stdc=no
3642 ac_save_CC=$CC
3643 cat >conftest.$ac_ext <<_ACEOF
3644 /* confdefs.h.  */
3645 _ACEOF
3646 cat confdefs.h >>conftest.$ac_ext
3647 cat >>conftest.$ac_ext <<_ACEOF
3648 /* end confdefs.h.  */
3649 #include <stdarg.h>
3650 #include <stdio.h>
3651 #include <sys/types.h>
3652 #include <sys/stat.h>
3653 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3654 struct buf { int x; };
3655 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3656 static char *e (p, i)
3657      char **p;
3658      int i;
3659 {
3660   return p[i];
3661 }
3662 static char *f (char * (*g) (char **, int), char **p, ...)
3663 {
3664   char *s;
3665   va_list v;
3666   va_start (v,p);
3667   s = g (p, va_arg (v,int));
3668   va_end (v);
3669   return s;
3670 }
3671
3672 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3673    function prototypes and stuff, but not '\xHH' hex character constants.
3674    These don't provoke an error unfortunately, instead are silently treated
3675    as 'x'.  The following induces an error, until -std1 is added to get
3676    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3677    array size at least.  It's necessary to write '\x00'==0 to get something
3678    that's true only with -std1.  */
3679 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3680
3681 int test (int i, double x);
3682 struct s1 {int (*f) (int a);};
3683 struct s2 {int (*f) (double a);};
3684 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3685 int argc;
3686 char **argv;
3687 int
3688 main ()
3689 {
3690 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3691   ;
3692   return 0;
3693 }
3694 _ACEOF
3695 # Don't try gcc -ansi; that turns off useful extensions and
3696 # breaks some systems' header files.
3697 # AIX                   -qlanglvl=ansi
3698 # Ultrix and OSF/1      -std1
3699 # HP-UX 10.20 and later -Ae
3700 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3701 # SVR4                  -Xc -D__EXTENSIONS__
3702 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3703 do
3704   CC="$ac_save_CC $ac_arg"
3705   rm -f conftest.$ac_objext
3706 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3707   (eval $ac_compile) 2>conftest.er1
3708   ac_status=$?
3709   grep -v '^ *+' conftest.er1 >conftest.err
3710   rm -f conftest.er1
3711   cat conftest.err >&5
3712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3713   (exit $ac_status); } &&
3714          { ac_try='test -z "$ac_c_werror_flag"
3715                          || test ! -s conftest.err'
3716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3717   (eval $ac_try) 2>&5
3718   ac_status=$?
3719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3720   (exit $ac_status); }; } &&
3721          { ac_try='test -s conftest.$ac_objext'
3722   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3723   (eval $ac_try) 2>&5
3724   ac_status=$?
3725   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3726   (exit $ac_status); }; }; then
3727   ac_cv_prog_cc_stdc=$ac_arg
3728 break
3729 else
3730   echo "$as_me: failed program was:" >&5
3731 sed 's/^/| /' conftest.$ac_ext >&5
3732
3733 fi
3734 rm -f conftest.err conftest.$ac_objext
3735 done
3736 rm -f conftest.$ac_ext conftest.$ac_objext
3737 CC=$ac_save_CC
3738
3739 fi
3740
3741 case "x$ac_cv_prog_cc_stdc" in
3742   x|xno)
3743     echo "$as_me:$LINENO: result: none needed" >&5
3744 echo "${ECHO_T}none needed" >&6 ;;
3745   *)
3746     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3747 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3748     CC="$CC $ac_cv_prog_cc_stdc" ;;
3749 esac
3750
3751 # Some people use a C++ compiler to compile C.  Since we use `exit',
3752 # in C++ we need to declare it.  In case someone uses the same compiler
3753 # for both compiling C and C++ we need to have the C++ compiler decide
3754 # the declaration of exit, since it's the most demanding environment.
3755 cat >conftest.$ac_ext <<_ACEOF
3756 #ifndef __cplusplus
3757   choke me
3758 #endif
3759 _ACEOF
3760 rm -f conftest.$ac_objext
3761 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3762   (eval $ac_compile) 2>conftest.er1
3763   ac_status=$?
3764   grep -v '^ *+' conftest.er1 >conftest.err
3765   rm -f conftest.er1
3766   cat conftest.err >&5
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); } &&
3769          { ac_try='test -z "$ac_c_werror_flag"
3770                          || test ! -s conftest.err'
3771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3772   (eval $ac_try) 2>&5
3773   ac_status=$?
3774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3775   (exit $ac_status); }; } &&
3776          { ac_try='test -s conftest.$ac_objext'
3777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3778   (eval $ac_try) 2>&5
3779   ac_status=$?
3780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3781   (exit $ac_status); }; }; then
3782   for ac_declaration in \
3783    '' \
3784    'extern "C" void std::exit (int) throw (); using std::exit;' \
3785    'extern "C" void std::exit (int); using std::exit;' \
3786    'extern "C" void exit (int) throw ();' \
3787    'extern "C" void exit (int);' \
3788    'void exit (int);'
3789 do
3790   cat >conftest.$ac_ext <<_ACEOF
3791 /* confdefs.h.  */
3792 _ACEOF
3793 cat confdefs.h >>conftest.$ac_ext
3794 cat >>conftest.$ac_ext <<_ACEOF
3795 /* end confdefs.h.  */
3796 $ac_declaration
3797 #include <stdlib.h>
3798 int
3799 main ()
3800 {
3801 exit (42);
3802   ;
3803   return 0;
3804 }
3805 _ACEOF
3806 rm -f conftest.$ac_objext
3807 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3808   (eval $ac_compile) 2>conftest.er1
3809   ac_status=$?
3810   grep -v '^ *+' conftest.er1 >conftest.err
3811   rm -f conftest.er1
3812   cat conftest.err >&5
3813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814   (exit $ac_status); } &&
3815          { ac_try='test -z "$ac_c_werror_flag"
3816                          || test ! -s conftest.err'
3817   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3818   (eval $ac_try) 2>&5
3819   ac_status=$?
3820   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3821   (exit $ac_status); }; } &&
3822          { ac_try='test -s conftest.$ac_objext'
3823   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3824   (eval $ac_try) 2>&5
3825   ac_status=$?
3826   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3827   (exit $ac_status); }; }; then
3828   :
3829 else
3830   echo "$as_me: failed program was:" >&5
3831 sed 's/^/| /' conftest.$ac_ext >&5
3832
3833 continue
3834 fi
3835 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3836   cat >conftest.$ac_ext <<_ACEOF
3837 /* confdefs.h.  */
3838 _ACEOF
3839 cat confdefs.h >>conftest.$ac_ext
3840 cat >>conftest.$ac_ext <<_ACEOF
3841 /* end confdefs.h.  */
3842 $ac_declaration
3843 int
3844 main ()
3845 {
3846 exit (42);
3847   ;
3848   return 0;
3849 }
3850 _ACEOF
3851 rm -f conftest.$ac_objext
3852 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3853   (eval $ac_compile) 2>conftest.er1
3854   ac_status=$?
3855   grep -v '^ *+' conftest.er1 >conftest.err
3856   rm -f conftest.er1
3857   cat conftest.err >&5
3858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3859   (exit $ac_status); } &&
3860          { ac_try='test -z "$ac_c_werror_flag"
3861                          || test ! -s conftest.err'
3862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3863   (eval $ac_try) 2>&5
3864   ac_status=$?
3865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3866   (exit $ac_status); }; } &&
3867          { ac_try='test -s conftest.$ac_objext'
3868   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3869   (eval $ac_try) 2>&5
3870   ac_status=$?
3871   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3872   (exit $ac_status); }; }; then
3873   break
3874 else
3875   echo "$as_me: failed program was:" >&5
3876 sed 's/^/| /' conftest.$ac_ext >&5
3877
3878 fi
3879 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3880 done
3881 rm -f conftest*
3882 if test -n "$ac_declaration"; then
3883   echo '#ifdef __cplusplus' >>confdefs.h
3884   echo $ac_declaration      >>confdefs.h
3885   echo '#endif'             >>confdefs.h
3886 fi
3887
3888 else
3889   echo "$as_me: failed program was:" >&5
3890 sed 's/^/| /' conftest.$ac_ext >&5
3891
3892 fi
3893 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3894 ac_ext=c
3895 ac_cpp='$CPP $CPPFLAGS'
3896 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3899
3900 ac_ext=cc
3901 ac_cpp='$CXXCPP $CPPFLAGS'
3902 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3903 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3904 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3905 if test -n "$ac_tool_prefix"; then
3906   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3907   do
3908     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3909 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3910 echo "$as_me:$LINENO: checking for $ac_word" >&5
3911 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3912 if test "${ac_cv_prog_CXX+set}" = set; then
3913   echo $ECHO_N "(cached) $ECHO_C" >&6
3914 else
3915   if test -n "$CXX"; then
3916   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3917 else
3918 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3919 for as_dir in $PATH
3920 do
3921   IFS=$as_save_IFS
3922   test -z "$as_dir" && as_dir=.
3923   for ac_exec_ext in '' $ac_executable_extensions; do
3924   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3925     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3926     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3927     break 2
3928   fi
3929 done
3930 done
3931
3932 fi
3933 fi
3934 CXX=$ac_cv_prog_CXX
3935 if test -n "$CXX"; then
3936   echo "$as_me:$LINENO: result: $CXX" >&5
3937 echo "${ECHO_T}$CXX" >&6
3938 else
3939   echo "$as_me:$LINENO: result: no" >&5
3940 echo "${ECHO_T}no" >&6
3941 fi
3942
3943     test -n "$CXX" && break
3944   done
3945 fi
3946 if test -z "$CXX"; then
3947   ac_ct_CXX=$CXX
3948   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3949 do
3950   # Extract the first word of "$ac_prog", so it can be a program name with args.
3951 set dummy $ac_prog; ac_word=$2
3952 echo "$as_me:$LINENO: checking for $ac_word" >&5
3953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3954 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3955   echo $ECHO_N "(cached) $ECHO_C" >&6
3956 else
3957   if test -n "$ac_ct_CXX"; then
3958   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3959 else
3960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3961 for as_dir in $PATH
3962 do
3963   IFS=$as_save_IFS
3964   test -z "$as_dir" && as_dir=.
3965   for ac_exec_ext in '' $ac_executable_extensions; do
3966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3967     ac_cv_prog_ac_ct_CXX="$ac_prog"
3968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3969     break 2
3970   fi
3971 done
3972 done
3973
3974 fi
3975 fi
3976 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3977 if test -n "$ac_ct_CXX"; then
3978   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3979 echo "${ECHO_T}$ac_ct_CXX" >&6
3980 else
3981   echo "$as_me:$LINENO: result: no" >&5
3982 echo "${ECHO_T}no" >&6
3983 fi
3984
3985   test -n "$ac_ct_CXX" && break
3986 done
3987 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3988
3989   CXX=$ac_ct_CXX
3990 fi
3991
3992
3993 # Provide some information about the compiler.
3994 echo "$as_me:$LINENO:" \
3995      "checking for C++ compiler version" >&5
3996 ac_compiler=`set X $ac_compile; echo $2`
3997 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3998   (eval $ac_compiler --version </dev/null >&5) 2>&5
3999   ac_status=$?
4000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4001   (exit $ac_status); }
4002 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4003   (eval $ac_compiler -v </dev/null >&5) 2>&5
4004   ac_status=$?
4005   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4006   (exit $ac_status); }
4007 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4008   (eval $ac_compiler -V </dev/null >&5) 2>&5
4009   ac_status=$?
4010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4011   (exit $ac_status); }
4012
4013 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4014 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4015 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4016   echo $ECHO_N "(cached) $ECHO_C" >&6
4017 else
4018   cat >conftest.$ac_ext <<_ACEOF
4019 /* confdefs.h.  */
4020 _ACEOF
4021 cat confdefs.h >>conftest.$ac_ext
4022 cat >>conftest.$ac_ext <<_ACEOF
4023 /* end confdefs.h.  */
4024
4025 int
4026 main ()
4027 {
4028 #ifndef __GNUC__
4029        choke me
4030 #endif
4031
4032   ;
4033   return 0;
4034 }
4035 _ACEOF
4036 rm -f conftest.$ac_objext
4037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4038   (eval $ac_compile) 2>conftest.er1
4039   ac_status=$?
4040   grep -v '^ *+' conftest.er1 >conftest.err
4041   rm -f conftest.er1
4042   cat conftest.err >&5
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); } &&
4045          { ac_try='test -z "$ac_cxx_werror_flag"
4046                          || test ! -s conftest.err'
4047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4048   (eval $ac_try) 2>&5
4049   ac_status=$?
4050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4051   (exit $ac_status); }; } &&
4052          { ac_try='test -s conftest.$ac_objext'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; }; then
4058   ac_compiler_gnu=yes
4059 else
4060   echo "$as_me: failed program was:" >&5
4061 sed 's/^/| /' conftest.$ac_ext >&5
4062
4063 ac_compiler_gnu=no
4064 fi
4065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4066 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4067
4068 fi
4069 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4070 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4071 GXX=`test $ac_compiler_gnu = yes && echo yes`
4072 ac_test_CXXFLAGS=${CXXFLAGS+set}
4073 ac_save_CXXFLAGS=$CXXFLAGS
4074 CXXFLAGS="-g"
4075 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4076 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4077 if test "${ac_cv_prog_cxx_g+set}" = set; then
4078   echo $ECHO_N "(cached) $ECHO_C" >&6
4079 else
4080   cat >conftest.$ac_ext <<_ACEOF
4081 /* confdefs.h.  */
4082 _ACEOF
4083 cat confdefs.h >>conftest.$ac_ext
4084 cat >>conftest.$ac_ext <<_ACEOF
4085 /* end confdefs.h.  */
4086
4087 int
4088 main ()
4089 {
4090
4091   ;
4092   return 0;
4093 }
4094 _ACEOF
4095 rm -f conftest.$ac_objext
4096 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4097   (eval $ac_compile) 2>conftest.er1
4098   ac_status=$?
4099   grep -v '^ *+' conftest.er1 >conftest.err
4100   rm -f conftest.er1
4101   cat conftest.err >&5
4102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103   (exit $ac_status); } &&
4104          { ac_try='test -z "$ac_cxx_werror_flag"
4105                          || test ! -s conftest.err'
4106   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4107   (eval $ac_try) 2>&5
4108   ac_status=$?
4109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4110   (exit $ac_status); }; } &&
4111          { ac_try='test -s conftest.$ac_objext'
4112   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4113   (eval $ac_try) 2>&5
4114   ac_status=$?
4115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4116   (exit $ac_status); }; }; then
4117   ac_cv_prog_cxx_g=yes
4118 else
4119   echo "$as_me: failed program was:" >&5
4120 sed 's/^/| /' conftest.$ac_ext >&5
4121
4122 ac_cv_prog_cxx_g=no
4123 fi
4124 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4125 fi
4126 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4127 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4128 if test "$ac_test_CXXFLAGS" = set; then
4129   CXXFLAGS=$ac_save_CXXFLAGS
4130 elif test $ac_cv_prog_cxx_g = yes; then
4131   if test "$GXX" = yes; then
4132     CXXFLAGS="-g -O2"
4133   else
4134     CXXFLAGS="-g"
4135   fi
4136 else
4137   if test "$GXX" = yes; then
4138     CXXFLAGS="-O2"
4139   else
4140     CXXFLAGS=
4141   fi
4142 fi
4143 for ac_declaration in \
4144    '' \
4145    'extern "C" void std::exit (int) throw (); using std::exit;' \
4146    'extern "C" void std::exit (int); using std::exit;' \
4147    'extern "C" void exit (int) throw ();' \
4148    'extern "C" void exit (int);' \
4149    'void exit (int);'
4150 do
4151   cat >conftest.$ac_ext <<_ACEOF
4152 /* confdefs.h.  */
4153 _ACEOF
4154 cat confdefs.h >>conftest.$ac_ext
4155 cat >>conftest.$ac_ext <<_ACEOF
4156 /* end confdefs.h.  */
4157 $ac_declaration
4158 #include <stdlib.h>
4159 int
4160 main ()
4161 {
4162 exit (42);
4163   ;
4164   return 0;
4165 }
4166 _ACEOF
4167 rm -f conftest.$ac_objext
4168 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4169   (eval $ac_compile) 2>conftest.er1
4170   ac_status=$?
4171   grep -v '^ *+' conftest.er1 >conftest.err
4172   rm -f conftest.er1
4173   cat conftest.err >&5
4174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4175   (exit $ac_status); } &&
4176          { ac_try='test -z "$ac_cxx_werror_flag"
4177                          || test ! -s conftest.err'
4178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4179   (eval $ac_try) 2>&5
4180   ac_status=$?
4181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4182   (exit $ac_status); }; } &&
4183          { ac_try='test -s conftest.$ac_objext'
4184   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4185   (eval $ac_try) 2>&5
4186   ac_status=$?
4187   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4188   (exit $ac_status); }; }; then
4189   :
4190 else
4191   echo "$as_me: failed program was:" >&5
4192 sed 's/^/| /' conftest.$ac_ext >&5
4193
4194 continue
4195 fi
4196 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4197   cat >conftest.$ac_ext <<_ACEOF
4198 /* confdefs.h.  */
4199 _ACEOF
4200 cat confdefs.h >>conftest.$ac_ext
4201 cat >>conftest.$ac_ext <<_ACEOF
4202 /* end confdefs.h.  */
4203 $ac_declaration
4204 int
4205 main ()
4206 {
4207 exit (42);
4208   ;
4209   return 0;
4210 }
4211 _ACEOF
4212 rm -f conftest.$ac_objext
4213 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4214   (eval $ac_compile) 2>conftest.er1
4215   ac_status=$?
4216   grep -v '^ *+' conftest.er1 >conftest.err
4217   rm -f conftest.er1
4218   cat conftest.err >&5
4219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4220   (exit $ac_status); } &&
4221          { ac_try='test -z "$ac_cxx_werror_flag"
4222                          || test ! -s conftest.err'
4223   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4224   (eval $ac_try) 2>&5
4225   ac_status=$?
4226   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4227   (exit $ac_status); }; } &&
4228          { ac_try='test -s conftest.$ac_objext'
4229   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4230   (eval $ac_try) 2>&5
4231   ac_status=$?
4232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4233   (exit $ac_status); }; }; then
4234   break
4235 else
4236   echo "$as_me: failed program was:" >&5
4237 sed 's/^/| /' conftest.$ac_ext >&5
4238
4239 fi
4240 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4241 done
4242 rm -f conftest*
4243 if test -n "$ac_declaration"; then
4244   echo '#ifdef __cplusplus' >>confdefs.h
4245   echo $ac_declaration      >>confdefs.h
4246   echo '#endif'             >>confdefs.h
4247 fi
4248
4249 ac_ext=c
4250 ac_cpp='$CPP $CPPFLAGS'
4251 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4252 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4253 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4254
4255
4256 # We must set the default linker to the linker used by gcc for the correct
4257 # operation of libtool.  If LD is not defined and we are using gcc, try to
4258 # set the LD default to the ld used by gcc.
4259 if test -z "$LD"; then
4260   if test "$GCC" = yes; then
4261     case $build in
4262     *-*-mingw*)
4263       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4264     *)
4265       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4266     esac
4267     case $gcc_prog_ld in
4268     # Accept absolute paths.
4269     [\\/]* | [A-Za-z]:[\\/]*)
4270       LD="$gcc_prog_ld" ;;
4271     esac
4272   fi
4273 fi
4274
4275
4276
4277
4278 if test -n "$ac_tool_prefix"; then
4279   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4280 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4281 echo "$as_me:$LINENO: checking for $ac_word" >&5
4282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4283 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4284   echo $ECHO_N "(cached) $ECHO_C" >&6
4285 else
4286   if test -n "$GNATBIND"; then
4287   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4288 else
4289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4290 for as_dir in $PATH
4291 do
4292   IFS=$as_save_IFS
4293   test -z "$as_dir" && as_dir=.
4294   for ac_exec_ext in '' $ac_executable_extensions; do
4295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4296     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4298     break 2
4299   fi
4300 done
4301 done
4302
4303 fi
4304 fi
4305 GNATBIND=$ac_cv_prog_GNATBIND
4306 if test -n "$GNATBIND"; then
4307   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4308 echo "${ECHO_T}$GNATBIND" >&6
4309 else
4310   echo "$as_me:$LINENO: result: no" >&5
4311 echo "${ECHO_T}no" >&6
4312 fi
4313
4314 fi
4315 if test -z "$ac_cv_prog_GNATBIND"; then
4316   ac_ct_GNATBIND=$GNATBIND
4317   # Extract the first word of "gnatbind", so it can be a program name with args.
4318 set dummy gnatbind; ac_word=$2
4319 echo "$as_me:$LINENO: checking for $ac_word" >&5
4320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4321 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4322   echo $ECHO_N "(cached) $ECHO_C" >&6
4323 else
4324   if test -n "$ac_ct_GNATBIND"; then
4325   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4326 else
4327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4328 for as_dir in $PATH
4329 do
4330   IFS=$as_save_IFS
4331   test -z "$as_dir" && as_dir=.
4332   for ac_exec_ext in '' $ac_executable_extensions; do
4333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4334     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4336     break 2
4337   fi
4338 done
4339 done
4340
4341   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4342 fi
4343 fi
4344 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4345 if test -n "$ac_ct_GNATBIND"; then
4346   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4347 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4348 else
4349   echo "$as_me:$LINENO: result: no" >&5
4350 echo "${ECHO_T}no" >&6
4351 fi
4352
4353   GNATBIND=$ac_ct_GNATBIND
4354 else
4355   GNATBIND="$ac_cv_prog_GNATBIND"
4356 fi
4357
4358 if test -n "$ac_tool_prefix"; then
4359   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4360 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4361 echo "$as_me:$LINENO: checking for $ac_word" >&5
4362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4363 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4364   echo $ECHO_N "(cached) $ECHO_C" >&6
4365 else
4366   if test -n "$GNATMAKE"; then
4367   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4368 else
4369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4370 for as_dir in $PATH
4371 do
4372   IFS=$as_save_IFS
4373   test -z "$as_dir" && as_dir=.
4374   for ac_exec_ext in '' $ac_executable_extensions; do
4375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4376     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4378     break 2
4379   fi
4380 done
4381 done
4382
4383 fi
4384 fi
4385 GNATMAKE=$ac_cv_prog_GNATMAKE
4386 if test -n "$GNATMAKE"; then
4387   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4388 echo "${ECHO_T}$GNATMAKE" >&6
4389 else
4390   echo "$as_me:$LINENO: result: no" >&5
4391 echo "${ECHO_T}no" >&6
4392 fi
4393
4394 fi
4395 if test -z "$ac_cv_prog_GNATMAKE"; then
4396   ac_ct_GNATMAKE=$GNATMAKE
4397   # Extract the first word of "gnatmake", so it can be a program name with args.
4398 set dummy gnatmake; ac_word=$2
4399 echo "$as_me:$LINENO: checking for $ac_word" >&5
4400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4401 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4402   echo $ECHO_N "(cached) $ECHO_C" >&6
4403 else
4404   if test -n "$ac_ct_GNATMAKE"; then
4405   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4406 else
4407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4408 for as_dir in $PATH
4409 do
4410   IFS=$as_save_IFS
4411   test -z "$as_dir" && as_dir=.
4412   for ac_exec_ext in '' $ac_executable_extensions; do
4413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4414     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4416     break 2
4417   fi
4418 done
4419 done
4420
4421   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4422 fi
4423 fi
4424 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4425 if test -n "$ac_ct_GNATMAKE"; then
4426   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4427 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4428 else
4429   echo "$as_me:$LINENO: result: no" >&5
4430 echo "${ECHO_T}no" >&6
4431 fi
4432
4433   GNATMAKE=$ac_ct_GNATMAKE
4434 else
4435   GNATMAKE="$ac_cv_prog_GNATMAKE"
4436 fi
4437
4438 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4439 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4440 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4441   echo $ECHO_N "(cached) $ECHO_C" >&6
4442 else
4443   cat >conftest.adb <<EOF
4444 procedure conftest is begin null; end conftest;
4445 EOF
4446 acx_cv_cc_gcc_supports_ada=no
4447 # There is a bug in old released versions of GCC which causes the
4448 # driver to exit successfully when the appropriate language module
4449 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4450 # Therefore we must check for the error message as well as an
4451 # unsuccessful exit.
4452 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4453 # given a .adb file, but produce no object file.  So we must check
4454 # if an object file was really produced to guard against this.
4455 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4456 if test x"$errors" = x && test -f conftest.$ac_objext; then
4457   acx_cv_cc_gcc_supports_ada=yes
4458 fi
4459 rm -f conftest.*
4460 fi
4461 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4462 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4463
4464 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4465   have_gnat=yes
4466 else
4467   have_gnat=no
4468 fi
4469
4470 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4471 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4472 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4473   echo $ECHO_N "(cached) $ECHO_C" >&6
4474 else
4475    echo abfoo >t1
4476   echo cdfoo >t2
4477   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4478   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4479     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4480       :
4481     else
4482       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4483     fi
4484   fi
4485   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4486     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4487       :
4488     else
4489       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4490     fi
4491   fi
4492   rm t1 t2
4493
4494 fi
4495 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4496 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4497 do_compare="$gcc_cv_prog_cmp_skip"
4498
4499
4500
4501 # Check for GMP and MPFR
4502 gmplibs="-lmpfr -lgmp"
4503 gmpinc=
4504 have_gmp=no
4505
4506 # Specify a location for mpfr
4507 # check for this first so it ends up on the link line before gmp.
4508
4509 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4510 if test "${with_mpfr_dir+set}" = set; then
4511   withval="$with_mpfr_dir"
4512   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4513 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4514 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4515 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4516    { (exit 1); exit 1; }; }
4517 fi;
4518
4519
4520 # Check whether --with-mpfr or --without-mpfr was given.
4521 if test "${with_mpfr+set}" = set; then
4522   withval="$with_mpfr"
4523
4524 fi;
4525
4526 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4527 if test "${with_mpfr_include+set}" = set; then
4528   withval="$with_mpfr_include"
4529
4530 fi;
4531
4532 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4533 if test "${with_mpfr_lib+set}" = set; then
4534   withval="$with_mpfr_lib"
4535
4536 fi;
4537
4538 if test "x$with_mpfr" != x; then
4539   gmplibs="-L$with_mpfr/lib $gmplibs"
4540   gmpinc="-I$with_mpfr/include"
4541 fi
4542 if test "x$with_mpfr_include" != x; then
4543   gmpinc="-I$with_mpfr_include"
4544 fi
4545 if test "x$with_mpfr_lib" != x; then
4546   gmplibs="-L$with_mpfr_lib $gmplibs"
4547 fi
4548 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4549   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4550   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4551   # Do not test the mpfr version.  Assume that it is sufficient, since
4552   # it is in the source tree, and the library has not been built yet
4553   # but it would be included on the link line in the version check below
4554   # hence making the test fail.
4555   have_gmp=yes
4556 fi
4557
4558 # Specify a location for gmp
4559
4560 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4561 if test "${with_gmp_dir+set}" = set; then
4562   withval="$with_gmp_dir"
4563   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4564 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4565 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4566 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4567    { (exit 1); exit 1; }; }
4568 fi;
4569
4570
4571 # Check whether --with-gmp or --without-gmp was given.
4572 if test "${with_gmp+set}" = set; then
4573   withval="$with_gmp"
4574
4575 fi;
4576
4577 # Check whether --with-gmp_include or --without-gmp_include was given.
4578 if test "${with_gmp_include+set}" = set; then
4579   withval="$with_gmp_include"
4580
4581 fi;
4582
4583 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4584 if test "${with_gmp_lib+set}" = set; then
4585   withval="$with_gmp_lib"
4586
4587 fi;
4588
4589
4590 if test "x$with_gmp" != x; then
4591   gmplibs="-L$with_gmp/lib $gmplibs"
4592   gmpinc="-I$with_gmp/include $gmpinc"
4593 fi
4594 if test "x$with_gmp_include" != x; then
4595   gmpinc="-I$with_gmp_include $gmpinc"
4596 fi
4597 if test "x$with_gmp_lib" != x; then
4598   gmplibs="-L$with_gmp_lib $gmplibs"
4599 fi
4600 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4601   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4602   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4603   # Do not test the gmp version.  Assume that it is sufficient, since
4604   # it is in the source tree, and the library has not been built yet
4605   # but it would be included on the link line in the version check below
4606   # hence making the test fail.
4607   have_gmp=yes
4608 fi
4609
4610 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4611   have_gmp=yes
4612   saved_CFLAGS="$CFLAGS"
4613   CFLAGS="$CFLAGS $gmpinc"
4614   # Check GMP actually works
4615   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4616 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4617
4618 cat >conftest.$ac_ext <<_ACEOF
4619 /* confdefs.h.  */
4620 _ACEOF
4621 cat confdefs.h >>conftest.$ac_ext
4622 cat >>conftest.$ac_ext <<_ACEOF
4623 /* end confdefs.h.  */
4624 #include "gmp.h"
4625 int
4626 main ()
4627 {
4628
4629   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4630   choke me
4631   #endif
4632
4633   ;
4634   return 0;
4635 }
4636 _ACEOF
4637 rm -f conftest.$ac_objext
4638 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4639   (eval $ac_compile) 2>conftest.er1
4640   ac_status=$?
4641   grep -v '^ *+' conftest.er1 >conftest.err
4642   rm -f conftest.er1
4643   cat conftest.err >&5
4644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4645   (exit $ac_status); } &&
4646          { ac_try='test -z "$ac_c_werror_flag"
4647                          || test ! -s conftest.err'
4648   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4649   (eval $ac_try) 2>&5
4650   ac_status=$?
4651   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4652   (exit $ac_status); }; } &&
4653          { ac_try='test -s conftest.$ac_objext'
4654   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4655   (eval $ac_try) 2>&5
4656   ac_status=$?
4657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4658   (exit $ac_status); }; }; then
4659   echo "$as_me:$LINENO: result: yes" >&5
4660 echo "${ECHO_T}yes" >&6
4661 else
4662   echo "$as_me: failed program was:" >&5
4663 sed 's/^/| /' conftest.$ac_ext >&5
4664
4665 echo "$as_me:$LINENO: result: no" >&5
4666 echo "${ECHO_T}no" >&6; have_gmp=no
4667 fi
4668 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4669
4670   if test x"$have_gmp" = xyes; then
4671     saved_LIBS="$LIBS"
4672     LIBS="$LIBS $gmplibs"
4673         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4674 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4675     cat >conftest.$ac_ext <<_ACEOF
4676 /* confdefs.h.  */
4677 _ACEOF
4678 cat confdefs.h >>conftest.$ac_ext
4679 cat >>conftest.$ac_ext <<_ACEOF
4680 /* end confdefs.h.  */
4681 #include <gmp.h>
4682     #include <mpfr.h>
4683 int
4684 main ()
4685 {
4686
4687     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4688     choke me
4689     #endif
4690     mpfr_t n;
4691     mpfr_t x;
4692     int t;
4693     mpfr_init (n);
4694     mpfr_init (x);
4695     mpfr_atan2 (n, n, x, GMP_RNDN);
4696     mpfr_erfc (n, x, GMP_RNDN);
4697     mpfr_subnormalize (x, t, GMP_RNDN);
4698
4699   ;
4700   return 0;
4701 }
4702 _ACEOF
4703 rm -f conftest.$ac_objext conftest$ac_exeext
4704 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4705   (eval $ac_link) 2>conftest.er1
4706   ac_status=$?
4707   grep -v '^ *+' conftest.er1 >conftest.err
4708   rm -f conftest.er1
4709   cat conftest.err >&5
4710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4711   (exit $ac_status); } &&
4712          { ac_try='test -z "$ac_c_werror_flag"
4713                          || test ! -s conftest.err'
4714   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4715   (eval $ac_try) 2>&5
4716   ac_status=$?
4717   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4718   (exit $ac_status); }; } &&
4719          { ac_try='test -s conftest$ac_exeext'
4720   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4721   (eval $ac_try) 2>&5
4722   ac_status=$?
4723   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4724   (exit $ac_status); }; }; then
4725   cat >conftest.$ac_ext <<_ACEOF
4726 /* confdefs.h.  */
4727 _ACEOF
4728 cat confdefs.h >>conftest.$ac_ext
4729 cat >>conftest.$ac_ext <<_ACEOF
4730 /* end confdefs.h.  */
4731 #include <gmp.h>
4732     #include <mpfr.h>
4733 int
4734 main ()
4735 {
4736
4737     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4738     choke me
4739     #endif
4740     mpfr_t n; mpfr_init(n);
4741
4742   ;
4743   return 0;
4744 }
4745 _ACEOF
4746 rm -f conftest.$ac_objext conftest$ac_exeext
4747 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4748   (eval $ac_link) 2>conftest.er1
4749   ac_status=$?
4750   grep -v '^ *+' conftest.er1 >conftest.err
4751   rm -f conftest.er1
4752   cat conftest.err >&5
4753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4754   (exit $ac_status); } &&
4755          { ac_try='test -z "$ac_c_werror_flag"
4756                          || test ! -s conftest.err'
4757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4758   (eval $ac_try) 2>&5
4759   ac_status=$?
4760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4761   (exit $ac_status); }; } &&
4762          { ac_try='test -s conftest$ac_exeext'
4763   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4764   (eval $ac_try) 2>&5
4765   ac_status=$?
4766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4767   (exit $ac_status); }; }; then
4768   echo "$as_me:$LINENO: result: yes" >&5
4769 echo "${ECHO_T}yes" >&6
4770 else
4771   echo "$as_me: failed program was:" >&5
4772 sed 's/^/| /' conftest.$ac_ext >&5
4773
4774 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4775 echo "${ECHO_T}buggy but acceptable" >&6
4776 fi
4777 rm -f conftest.err conftest.$ac_objext \
4778       conftest$ac_exeext conftest.$ac_ext
4779 else
4780   echo "$as_me: failed program was:" >&5
4781 sed 's/^/| /' conftest.$ac_ext >&5
4782
4783 echo "$as_me:$LINENO: result: no" >&5
4784 echo "${ECHO_T}no" >&6; have_gmp=no
4785 fi
4786 rm -f conftest.err conftest.$ac_objext \
4787       conftest$ac_exeext conftest.$ac_ext
4788       LIBS="$saved_LIBS"
4789   fi
4790   CFLAGS="$saved_CFLAGS"
4791
4792   if test x$have_gmp != xyes; then
4793     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4794 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4795 Copies of these libraries' source code can be found at their respective
4796 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4797 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4798 If you obtained GMP and/or MPFR from a vendor distribution package, make
4799 sure that you have installed both the libraries and the header files.
4800 They may be located in separate packages." >&5
4801 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4802 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4803 Copies of these libraries' source code can be found at their respective
4804 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4805 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4806 If you obtained GMP and/or MPFR from a vendor distribution package, make
4807 sure that you have installed both the libraries and the header files.
4808 They may be located in separate packages." >&2;}
4809    { (exit 1); exit 1; }; }
4810   fi
4811 fi
4812
4813 # Flags needed for both GMP and/or MPFR
4814
4815
4816
4817 # Allow host libstdc++ to be specified for static linking with PPL.
4818
4819 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4820 if test "${with_host_libstdcxx+set}" = set; then
4821   withval="$with_host_libstdcxx"
4822
4823 fi;
4824
4825 case $with_host_libstdcxx in
4826   no|yes)
4827     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4828 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4829    { (exit 1); exit 1; }; }
4830     ;;
4831 esac
4832
4833 # Check for PPL
4834 ppl_major_version=0
4835 ppl_minor_version=10
4836 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4837 pplinc=
4838
4839
4840 # Check whether --with-ppl or --without-ppl was given.
4841 if test "${with_ppl+set}" = set; then
4842   withval="$with_ppl"
4843
4844 fi;
4845
4846 # Check whether --with-ppl_include or --without-ppl_include was given.
4847 if test "${with_ppl_include+set}" = set; then
4848   withval="$with_ppl_include"
4849
4850 fi;
4851
4852 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4853 if test "${with_ppl_lib+set}" = set; then
4854   withval="$with_ppl_lib"
4855
4856 fi;
4857
4858 case $with_ppl in
4859   no)
4860     ppllibs=
4861     ;;
4862   *)
4863     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4864     pplinc="-I$with_ppl/include $pplinc"
4865     LIBS="$ppllibs $LIBS"
4866     ;;
4867 esac
4868 if test "x$with_ppl_include" != x; then
4869   pplinc="-I$with_ppl_include $pplinc"
4870 fi
4871 if test "x$with_ppl_lib" != x; then
4872   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4873   LIBS="$ppllibs $LIBS"
4874 fi
4875 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4876   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4877   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4878   LIBS="$ppllibs $LIBS"
4879 fi
4880
4881 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4882 if test "${enable_ppl_version_check+set}" = set; then
4883   enableval="$enable_ppl_version_check"
4884   ENABLE_PPL_CHECK=$enableval
4885 else
4886   ENABLE_PPL_CHECK=yes
4887 fi;
4888
4889 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4890   saved_CFLAGS="$CFLAGS"
4891   CFLAGS="$CFLAGS $pplinc $gmpinc"
4892   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4893 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4894   cat >conftest.$ac_ext <<_ACEOF
4895 /* confdefs.h.  */
4896 _ACEOF
4897 cat confdefs.h >>conftest.$ac_ext
4898 cat >>conftest.$ac_ext <<_ACEOF
4899 /* end confdefs.h.  */
4900 #include "ppl_c.h"
4901 int
4902 main ()
4903 {
4904
4905   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4906   choke me
4907   #endif
4908
4909   ;
4910   return 0;
4911 }
4912 _ACEOF
4913 rm -f conftest.$ac_objext
4914 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4915   (eval $ac_compile) 2>conftest.er1
4916   ac_status=$?
4917   grep -v '^ *+' conftest.er1 >conftest.err
4918   rm -f conftest.er1
4919   cat conftest.err >&5
4920   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4921   (exit $ac_status); } &&
4922          { ac_try='test -z "$ac_c_werror_flag"
4923                          || test ! -s conftest.err'
4924   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4925   (eval $ac_try) 2>&5
4926   ac_status=$?
4927   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4928   (exit $ac_status); }; } &&
4929          { ac_try='test -s conftest.$ac_objext'
4930   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4931   (eval $ac_try) 2>&5
4932   ac_status=$?
4933   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4934   (exit $ac_status); }; }; then
4935   echo "$as_me:$LINENO: result: yes" >&5
4936 echo "${ECHO_T}yes" >&6
4937 else
4938   echo "$as_me: failed program was:" >&5
4939 sed 's/^/| /' conftest.$ac_ext >&5
4940
4941 echo "$as_me:$LINENO: result: no" >&5
4942 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4943 fi
4944 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4945   CFLAGS="$saved_CFLAGS"
4946 fi
4947
4948 # Flags needed for PPL
4949
4950
4951
4952
4953 # Check for CLOOG
4954 clooglibs=" -lcloog "
4955 clooginc=" -DCLOOG_PPL_BACKEND "
4956
4957
4958 # Check whether --with-cloog or --without-cloog was given.
4959 if test "${with_cloog+set}" = set; then
4960   withval="$with_cloog"
4961
4962 fi;
4963
4964 # Check whether --with-cloog_include or --without-cloog_include was given.
4965 if test "${with_cloog_include+set}" = set; then
4966   withval="$with_cloog_include"
4967
4968 fi;
4969
4970 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4971 if test "${with_cloog_lib+set}" = set; then
4972   withval="$with_cloog_lib"
4973
4974 fi;
4975
4976 case $with_cloog in
4977   no)
4978     clooglibs=
4979     clooginc=
4980     ;;
4981   *)
4982     clooglibs="-L$with_cloog/lib -lcloog"
4983     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4984     LIBS="$clooglibs $LIBS"
4985     ;;
4986 esac
4987 if test "x$with_cloog_include" != x; then
4988   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4989 fi
4990 if test "x$with_cloog_lib" != x; then
4991   clooglibs="-L$with_cloog_lib -lcloog"
4992   LIBS="$clooglibs $LIBS"
4993 fi
4994 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4995   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4996   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4997   LIBS="$clooglibs $LIBS"
4998 fi
4999
5000 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5001 if test "${enable_cloog_version_check+set}" = set; then
5002   enableval="$enable_cloog_version_check"
5003   ENABLE_CLOOG_CHECK=$enableval
5004 else
5005   ENABLE_CLOOG_CHECK=yes
5006 fi;
5007
5008 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5009   saved_CFLAGS="$CFLAGS"
5010   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5011   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5012 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5013   cat >conftest.$ac_ext <<_ACEOF
5014 /* confdefs.h.  */
5015 _ACEOF
5016 cat confdefs.h >>conftest.$ac_ext
5017 cat >>conftest.$ac_ext <<_ACEOF
5018 /* end confdefs.h.  */
5019 #include "cloog/cloog.h"
5020 int
5021 main ()
5022 {
5023
5024   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5025   choke me
5026   #endif
5027
5028   ;
5029   return 0;
5030 }
5031 _ACEOF
5032 rm -f conftest.$ac_objext
5033 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5034   (eval $ac_compile) 2>conftest.er1
5035   ac_status=$?
5036   grep -v '^ *+' conftest.er1 >conftest.err
5037   rm -f conftest.er1
5038   cat conftest.err >&5
5039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5040   (exit $ac_status); } &&
5041          { ac_try='test -z "$ac_c_werror_flag"
5042                          || test ! -s conftest.err'
5043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5044   (eval $ac_try) 2>&5
5045   ac_status=$?
5046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5047   (exit $ac_status); }; } &&
5048          { ac_try='test -s conftest.$ac_objext'
5049   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5050   (eval $ac_try) 2>&5
5051   ac_status=$?
5052   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5053   (exit $ac_status); }; }; then
5054   echo "$as_me:$LINENO: result: yes" >&5
5055 echo "${ECHO_T}yes" >&6
5056 else
5057   echo "$as_me: failed program was:" >&5
5058 sed 's/^/| /' conftest.$ac_ext >&5
5059
5060 echo "$as_me:$LINENO: result: no" >&5
5061 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5062 fi
5063 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5064   CFLAGS="$saved_CFLAGS"
5065 fi
5066
5067 # Flags needed for CLOOG
5068
5069
5070
5071
5072 # By default, C is the only stage 1 language.
5073 stage1_languages=,c,
5074
5075 # Figure out what language subdirectories are present.
5076 # Look if the user specified --enable-languages="..."; if not, use
5077 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5078 # go away some day.
5079 # NB:  embedded tabs in this IF block -- do not untabify
5080 if test -d ${srcdir}/gcc; then
5081   if test x"${enable_languages+set}" != xset; then
5082     if test x"${LANGUAGES+set}" = xset; then
5083       enable_languages="${LANGUAGES}"
5084         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5085     else
5086       enable_languages=all
5087     fi
5088   else
5089     if test x"${enable_languages}" = x ||
5090        test x"${enable_languages}" = xyes;
5091        then
5092       echo configure.in: --enable-languages needs at least one language argument 1>&2
5093       exit 1
5094     fi
5095   fi
5096   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5097
5098   # 'f95' is the old name for the 'fortran' language. We issue a warning
5099   # and make the substitution.
5100   case ,${enable_languages}, in
5101     *,f95,*)
5102       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5103       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5104       ;;
5105   esac
5106
5107   # First scan to see if an enabled language requires some other language.
5108   # We assume that a given config-lang.in will list all the language
5109   # front ends it requires, even if some are required indirectly.
5110   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5111     case ${lang_frag} in
5112       ..) ;;
5113       # The odd quoting in the next line works around
5114       # an apparent bug in bash 1.12 on linux.
5115       ${srcdir}/gcc/[*]/config-lang.in) ;;
5116       *)
5117         # From the config-lang.in, get $language, $lang_requires
5118         language=
5119         lang_requires=
5120         . ${lang_frag}
5121         for other in ${lang_requires} ; do
5122           case ,${enable_languages}, in
5123             *,$other,*) ;;
5124             *,all,*) ;;
5125             *,$language,*)
5126               echo " \`$other' language required by \`$language'; enabling" 1>&2
5127               enable_languages="${enable_languages},${other}"
5128               ;;
5129           esac
5130         done
5131         ;;
5132     esac
5133   done
5134
5135   new_enable_languages=,c,
5136   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5137   potential_languages=,c,
5138
5139   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5140     case ${lang_frag} in
5141       ..) ;;
5142       # The odd quoting in the next line works around
5143       # an apparent bug in bash 1.12 on linux.
5144       ${srcdir}/gcc/[*]/config-lang.in) ;;
5145       *)
5146         # From the config-lang.in, get $language, $target_libs,
5147         # $lang_dirs, $boot_language, and $build_by_default
5148         language=
5149         target_libs=
5150         lang_dirs=
5151         subdir_requires=
5152         boot_language=no
5153         build_by_default=yes
5154         . ${lang_frag}
5155         if test x${language} = x; then
5156           echo "${lang_frag} doesn't set \$language." 1>&2
5157           exit 1
5158         fi
5159
5160         case ,${enable_languages}, in
5161           *,${language},*)
5162             # Language was explicitly selected; include it.
5163             add_this_lang=yes
5164             ;;
5165           *,all,*)
5166             # 'all' was selected, select it if it is a default language
5167             add_this_lang=${build_by_default}
5168             ;;
5169           *)
5170             add_this_lang=no
5171             ;;
5172         esac
5173
5174         # Disable languages that need other directories if these aren't available.
5175         for i in $subdir_requires; do
5176           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5177           case ,${enable_languages}, in
5178             *,${language},*)
5179               # Specifically requested language; tell them.
5180               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5181 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5182    { (exit 1); exit 1; }; }
5183               ;;
5184             *)
5185               # Silently disable.
5186               add_this_lang=unsupported
5187               ;;
5188           esac
5189         done
5190
5191         # Disable Ada if no preexisting GNAT is available.
5192         case ,${enable_languages},:${language}:${have_gnat} in
5193           *,${language},*:ada:no)
5194             # Specifically requested language; tell them.
5195             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5196 echo "$as_me: error: GNAT is required to build $language" >&2;}
5197    { (exit 1); exit 1; }; }
5198             ;;
5199           *:ada:no)
5200             # Silently disable.
5201             add_this_lang=unsupported
5202             ;;
5203         esac
5204
5205         # Disable a language that is unsupported by the target.
5206         case " $unsupported_languages " in
5207           *" $language "*)
5208             add_this_lang=unsupported
5209             ;;
5210         esac
5211
5212         case $add_this_lang in
5213           unsupported)
5214             # Remove language-dependent dirs.
5215             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5216             ;;
5217           no)
5218             # Remove language-dependent dirs; still show language as supported.
5219             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5220             potential_languages="${potential_languages}${language},"
5221             ;;
5222           yes)
5223             new_enable_languages="${new_enable_languages}${language},"
5224             potential_languages="${potential_languages}${language},"
5225             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5226             case ${boot_language} in
5227               yes)
5228                 # Add to (comma-separated) list of stage 1 languages.
5229                 stage1_languages="${stage1_languages}${language},"
5230                 ;;
5231             esac
5232             ;;
5233         esac
5234         ;;
5235     esac
5236   done
5237
5238   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5239 if test "${enable_stage1_languages+set}" = set; then
5240   enableval="$enable_stage1_languages"
5241   case ,${enable_stage1_languages}, in
5242     ,no,|,,)
5243       # Set it to something that will have no effect in the loop below
5244       enable_stage1_languages=c ;;
5245     ,yes,)
5246       enable_stage1_languages=`echo $new_enable_languages | \
5247         sed -e "s/^,//" -e "s/,$//" ` ;;
5248     *,all,*)
5249       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5250         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5251   esac
5252
5253   # Add "good" languages from enable_stage1_languages to stage1_languages,
5254   # while "bad" languages go in missing_languages.  Leave no duplicates.
5255   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5256     case $potential_languages in
5257       *,$i,*)
5258         case $stage1_languages in
5259           *,$i,*) ;;
5260           *) stage1_languages="$stage1_languages$i," ;;
5261         esac ;;
5262       *)
5263         case $missing_languages in
5264           *,$i,*) ;;
5265           *) missing_languages="$missing_languages$i," ;;
5266         esac ;;
5267      esac
5268   done
5269 fi;
5270
5271   # Remove leading/trailing commas that were added for simplicity
5272   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5273   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5274   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5275   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5276
5277   if test "x$missing_languages" != x; then
5278     { { echo "$as_me:$LINENO: error:
5279 The following requested languages could not be built: ${missing_languages}
5280 Supported languages are: ${potential_languages}" >&5
5281 echo "$as_me: error:
5282 The following requested languages could not be built: ${missing_languages}
5283 Supported languages are: ${potential_languages}" >&2;}
5284    { (exit 1); exit 1; }; }
5285   fi
5286   if test "x$new_enable_languages" != "x$enable_languages"; then
5287     echo The following languages will be built: ${new_enable_languages}
5288     enable_languages="$new_enable_languages"
5289   fi
5290
5291
5292   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5293 fi
5294
5295 # Handle --disable-<component> generically.
5296 for dir in $configdirs $build_configdirs $target_configdirs ; do
5297   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5298   varname=`echo $dirname | sed -e s/+/_/g`
5299   if eval test x\${enable_${varname}} "=" xno ; then
5300     noconfigdirs="$noconfigdirs $dir"
5301   fi
5302 done
5303
5304 # Check for Boehm's garbage collector
5305 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5306 if test "${enable_objc_gc+set}" = set; then
5307   enableval="$enable_objc_gc"
5308   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5309   *,objc,*:*:yes:*target-boehm-gc*)
5310     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5311 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5312    { (exit 1); exit 1; }; }
5313     ;;
5314 esac
5315 fi;
5316
5317 # Make sure we only build Boehm's garbage collector if required.
5318 case ,${enable_languages},:${enable_objc_gc} in
5319   *,objc,*:yes)
5320     # Keep target-boehm-gc if requested for Objective-C.
5321     ;;
5322   *)
5323     # Otherwise remove target-boehm-gc depending on target-libjava.
5324     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5325       noconfigdirs="$noconfigdirs target-boehm-gc"
5326     fi
5327     ;;
5328 esac
5329
5330 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5331 # $build_configdirs and $target_configdirs.
5332 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5333
5334 notsupp=""
5335 for dir in . $skipdirs $noconfigdirs ; do
5336   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5337   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5338     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5339     if test -r $srcdir/$dirname/configure ; then
5340       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5341         true
5342       else
5343         notsupp="$notsupp $dir"
5344       fi
5345     fi
5346   fi
5347   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5348     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5349     if test -r $srcdir/$dirname/configure ; then
5350       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5351         true
5352       else
5353         notsupp="$notsupp $dir"
5354       fi
5355     fi
5356   fi
5357   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5358     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5359     if test -r $srcdir/$dirname/configure ; then
5360       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5361         true
5362       else
5363         notsupp="$notsupp $dir"
5364       fi
5365     fi
5366   fi
5367 done
5368
5369 # Sometimes the tools are distributed with libiberty but with no other
5370 # libraries.  In that case, we don't want to build target-libiberty.
5371 # Don't let libgcc imply libiberty either.
5372 if test -n "${target_configdirs}" ; then
5373   libgcc=
5374   others=
5375   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5376     if test "$i" = "libgcc"; then
5377       libgcc=target-libgcc
5378     elif test "$i" != "libiberty" ; then
5379       if test -r $srcdir/$i/configure ; then
5380         others=yes;
5381         break;
5382       fi
5383     fi
5384   done
5385   if test -z "${others}" ; then
5386     target_configdirs=$libgcc
5387   fi
5388 fi
5389
5390 # Quietly strip out all directories which aren't configurable in this tree.
5391 # This relies on all configurable subdirectories being autoconfiscated, which
5392 # is now the case.
5393 build_configdirs_all="$build_configdirs"
5394 build_configdirs=
5395 for i in ${build_configdirs_all} ; do
5396   j=`echo $i | sed -e s/build-//g`
5397   if test -f ${srcdir}/$j/configure ; then
5398     build_configdirs="${build_configdirs} $i"
5399   fi
5400 done
5401
5402 configdirs_all="$configdirs"
5403 configdirs=
5404 for i in ${configdirs_all} ; do
5405   if test -f ${srcdir}/$i/configure ; then
5406     configdirs="${configdirs} $i"
5407   fi
5408 done
5409
5410 target_configdirs_all="$target_configdirs"
5411 target_configdirs=
5412 for i in ${target_configdirs_all} ; do
5413   j=`echo $i | sed -e s/target-//g`
5414   if test -f ${srcdir}/$j/configure ; then
5415     target_configdirs="${target_configdirs} $i"
5416   fi
5417 done
5418
5419 # Produce a warning message for the subdirs we can't configure.
5420 # This isn't especially interesting in the Cygnus tree, but in the individual
5421 # FSF releases, it's important to let people know when their machine isn't
5422 # supported by the one or two programs in a package.
5423
5424 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5425   # If $appdirs is non-empty, at least one of those directories must still
5426   # be configured, or we error out.  (E.g., if the gas release supports a
5427   # specified target in some subdirs but not the gas subdir, we shouldn't
5428   # pretend that all is well.)
5429   if test -n "$appdirs" ; then
5430     for dir in $appdirs ; do
5431       if test -r $dir/Makefile.in ; then
5432         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5433           appdirs=""
5434           break
5435         fi
5436         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5437           appdirs=""
5438           break
5439         fi
5440       fi
5441     done
5442     if test -n "$appdirs" ; then
5443       echo "*** This configuration is not supported by this package." 1>&2
5444       exit 1
5445     fi
5446   fi
5447   # Okay, some application will build, or we don't care to check.  Still
5448   # notify of subdirs not getting built.
5449   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5450   echo "    ${notsupp}" 1>&2
5451   echo "    (Any other directories should still work fine.)" 1>&2
5452 fi
5453
5454 case "$host" in
5455   *msdosdjgpp*)
5456     enable_gdbtk=no ;;
5457 esac
5458
5459 # To find our prefix, in gcc_cv_tool_prefix.
5460
5461 # The user is always right.
5462 if test "${PATH_SEPARATOR+set}" != set; then
5463   echo "#! /bin/sh" >conf$$.sh
5464   echo  "exit 0"   >>conf$$.sh
5465   chmod +x conf$$.sh
5466   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5467     PATH_SEPARATOR=';'
5468   else
5469     PATH_SEPARATOR=:
5470   fi
5471   rm -f conf$$.sh
5472 fi
5473
5474
5475
5476 if test "x$exec_prefix" = xNONE; then
5477         if test "x$prefix" = xNONE; then
5478                 gcc_cv_tool_prefix=$ac_default_prefix
5479         else
5480                 gcc_cv_tool_prefix=$prefix
5481         fi
5482 else
5483         gcc_cv_tool_prefix=$exec_prefix
5484 fi
5485
5486 # If there is no compiler in the tree, use the PATH only.  In any
5487 # case, if there is no compiler in the tree nobody should use
5488 # AS_FOR_TARGET and LD_FOR_TARGET.
5489 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5490     gcc_version=`cat $srcdir/gcc/BASE-VER`
5491     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5492     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5493     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5494     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5495     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5496     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5497 else
5498     gcc_cv_tool_dirs=
5499 fi
5500
5501 if test x$build = x$target && test -n "$md_exec_prefix"; then
5502         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5503 fi
5504
5505
5506
5507 copy_dirs=
5508
5509
5510 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5511 if test "${with_build_sysroot+set}" = set; then
5512   withval="$with_build_sysroot"
5513   if test x"$withval" != x ; then
5514      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5515    fi
5516 else
5517   SYSROOT_CFLAGS_FOR_TARGET=
5518 fi;
5519
5520
5521
5522 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5523 if test "${with_debug_prefix_map+set}" = set; then
5524   withval="$with_debug_prefix_map"
5525   if test x"$withval" != x; then
5526      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5527      for debug_map in $withval; do
5528        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5529      done
5530    fi
5531 else
5532   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5533 fi;
5534
5535
5536 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5537 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5538 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5539 # We want to ensure that TARGET libraries (which we know are built with
5540 # gcc) are built with "-O2 -g", so include those options when setting
5541 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5542 if test "x$CFLAGS_FOR_TARGET" = x; then
5543   CFLAGS_FOR_TARGET=$CFLAGS
5544   case " $CFLAGS " in
5545     *" -O2 "*) ;;
5546     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5547   esac
5548   case " $CFLAGS " in
5549     *" -g "* | *" -g3 "*) ;;
5550     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5551   esac
5552 fi
5553
5554
5555 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5556   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5557   case " $CXXFLAGS " in
5558     *" -O2 "*) ;;
5559     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5560   esac
5561   case " $CXXFLAGS " in
5562     *" -g "* | *" -g3 "*) ;;
5563     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5564   esac
5565 fi
5566
5567
5568 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5569 # the named directory are copied to $(tooldir)/sys-include.
5570 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5571   if test x${is_cross_compiler} = xno ; then
5572     echo 1>&2 '***' --with-headers is only supported when cross compiling
5573     exit 1
5574   fi
5575   if test x"${with_headers}" != xyes ; then
5576     x=${gcc_cv_tool_prefix}
5577     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5578   fi
5579 fi
5580
5581 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5582 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5583 # are permitted.
5584 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5585   if test x${is_cross_compiler} = xno ; then
5586     echo 1>&2 '***' --with-libs is only supported when cross compiling
5587     exit 1
5588   fi
5589   if test x"${with_libs}" != xyes ; then
5590     # Copy the libraries in reverse order, so that files in the first named
5591     # library override files in subsequent libraries.
5592     x=${gcc_cv_tool_prefix}
5593     for l in ${with_libs}; do
5594       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5595     done
5596   fi
5597 fi
5598
5599 # Set with_gnu_as and with_gnu_ld as appropriate.
5600 #
5601 # This is done by determining whether or not the appropriate directory
5602 # is available, and by checking whether or not specific configurations
5603 # have requested that this magic not happen.
5604 #
5605 # The command line options always override the explicit settings in
5606 # configure.in, and the settings in configure.in override this magic.
5607 #
5608 # If the default for a toolchain is to use GNU as and ld, and you don't
5609 # want to do that, then you should use the --without-gnu-as and
5610 # --without-gnu-ld options for the configure script.
5611
5612 if test x${use_gnu_as} = x &&
5613    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5614   with_gnu_as=yes
5615   extra_host_args="$extra_host_args --with-gnu-as"
5616 fi
5617
5618 if test x${use_gnu_ld} = x &&
5619    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5620   with_gnu_ld=yes
5621   extra_host_args="$extra_host_args --with-gnu-ld"
5622 fi
5623
5624 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5625 # can detect this case.
5626
5627 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5628   with_newlib=yes
5629   extra_host_args="$extra_host_args --with-newlib"
5630 fi
5631
5632 # Handle ${copy_dirs}
5633 set fnord ${copy_dirs}
5634 shift
5635 while test $# != 0 ; do
5636   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5637     :
5638   else
5639     echo Copying $1 to $2
5640
5641     # Use the install script to create the directory and all required
5642     # parent directories.
5643     if test -d $2 ; then
5644       :
5645     else
5646       echo >config.temp
5647       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5648     fi
5649
5650     # Copy the directory, assuming we have tar.
5651     # FIXME: Should we use B in the second tar?  Not all systems support it.
5652     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5653
5654     # It is the responsibility of the user to correctly adjust all
5655     # symlinks.  If somebody can figure out how to handle them correctly
5656     # here, feel free to add the code.
5657
5658     echo $1 > $2/COPIED
5659   fi
5660   shift; shift
5661 done
5662
5663 # Determine a target-dependent exec_prefix that the installed
5664 # gcc will search in.  Keep this list sorted by triplet, with
5665 # the *-*-osname triplets last.
5666 md_exec_prefix=
5667 case "${target}" in
5668   alpha*-*-*vms*)
5669     md_exec_prefix=/gnu/lib/gcc-lib
5670     ;;
5671   i[34567]86-pc-msdosdjgpp*)
5672     md_exec_prefix=/dev/env/DJDIR/bin
5673     ;;
5674   i[34567]86-*-sco3.2v5*)
5675     if test $with_gnu_as = yes; then
5676       md_exec_prefix=/usr/gnu/bin
5677     else
5678       md_exec_prefix=/usr/ccs/bin/elf
5679     fi
5680     ;;
5681
5682   mn10300-*-* | \
5683   powerpc-*-chorusos* | \
5684   powerpc*-*-eabi* | \
5685   powerpc*-*-sysv* | \
5686   powerpc*-*-kaos* | \
5687   s390x-ibm-tpf*)
5688     md_exec_prefix=/usr/ccs/bin
5689     ;;
5690   sparc64-*-elf*)
5691     ;;
5692   v850*-*-*)
5693     md_exec_prefix=/usr/ccs/bin
5694     ;;
5695   xtensa*-*-elf*)
5696     ;;
5697
5698   *-*-beos* | \
5699   *-*-elf* | \
5700   *-*-hpux* | \
5701   *-*-netware* | \
5702   *-*-nto-qnx* | \
5703   *-*-rtems* | \
5704   *-*-solaris2* | \
5705   *-*-sysv[45]* | \
5706   *-*-vxworks* | \
5707   *-wrs-windiss)
5708     md_exec_prefix=/usr/ccs/bin
5709     ;;
5710 esac
5711
5712 extra_arflags_for_target=
5713 extra_nmflags_for_target=
5714 extra_ranlibflags_for_target=
5715 target_makefile_frag=/dev/null
5716 case "${target}" in
5717   mep*-*-*)
5718     target_makefile_frag="config/mt-mep"
5719     ;;
5720   spu-*-*)
5721     target_makefile_frag="config/mt-spu"
5722     ;;
5723   mips*-sde-elf*)
5724     target_makefile_frag="config/mt-sde"
5725     ;;
5726   mipsisa*-*-elfoabi*)
5727     target_makefile_frag="config/mt-mips-elfoabi"
5728     ;;
5729   mips*-*-*linux* | mips*-*-gnu*)
5730     target_makefile_frag="config/mt-mips-gnu"
5731     ;;
5732   *-*-netware*)
5733     target_makefile_frag="config/mt-netware"
5734     ;;
5735   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5736     target_makefile_frag="config/mt-gnu"
5737     ;;
5738   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5739     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5740     # commands to handle both 32-bit and 64-bit objects.  These flags are
5741     # harmless if we're using GNU nm or ar.
5742     extra_arflags_for_target=" -X32_64"
5743     extra_nmflags_for_target=" -B -X32_64"
5744     ;;
5745   *-*-darwin*)
5746     # ranlib from Darwin requires the -c flag to look at common symbols.
5747     extra_ranlibflags_for_target=" -c"
5748     ;;
5749   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5750     target_makefile_frag="config/mt-wince"
5751     ;;
5752 esac
5753
5754 alphaieee_frag=/dev/null
5755 case $target in
5756   alpha*-*-*)
5757     # This just makes sure to use the -mieee option to build target libs.
5758     # This should probably be set individually by each library.
5759     alphaieee_frag="config/mt-alphaieee"
5760     ;;
5761 esac
5762
5763 # If --enable-target-optspace always use -Os instead of -O2 to build
5764 # the target libraries, similarly if it is not specified, use -Os
5765 # on selected platforms.
5766 ospace_frag=/dev/null
5767 case "${enable_target_optspace}:${target}" in
5768   yes:*)
5769     ospace_frag="config/mt-ospace"
5770     ;;
5771   :d30v-*)
5772     ospace_frag="config/mt-d30v"
5773     ;;
5774   :m32r-* | :d10v-* | :fr30-*)
5775     ospace_frag="config/mt-ospace"
5776     ;;
5777   no:* | :*)
5778     ;;
5779   *)
5780     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5781     ;;
5782 esac
5783
5784 # Default to using --with-stabs for certain targets.
5785 if test x${with_stabs} = x ; then
5786   case "${target}" in
5787   mips*-*-irix[56]*)
5788     ;;
5789   mips*-*-* | alpha*-*-osf*)
5790     with_stabs=yes;
5791     extra_host_args="${extra_host_args} --with-stabs"
5792     ;;
5793   esac
5794 fi
5795
5796 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5797 # them automatically.
5798 case "${host}" in
5799   hppa*64*-*-hpux11*)
5800     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5801     ;;
5802 esac
5803
5804 # Some systems (e.g., one of the i386-aix systems the gas testers are
5805 # using) don't handle "\$" correctly, so don't use it here.
5806 tooldir='${exec_prefix}'/${target_noncanonical}
5807 build_tooldir=${tooldir}
5808
5809 # Create a .gdbinit file which runs the one in srcdir
5810 # and tells GDB to look there for source files.
5811
5812 if test -r ${srcdir}/.gdbinit ; then
5813   case ${srcdir} in
5814     .) ;;
5815     *) cat > ./.gdbinit <<EOF
5816 # ${NO_EDIT}
5817 dir ${srcdir}
5818 dir .
5819 source ${srcdir}/.gdbinit
5820 EOF
5821     ;;
5822   esac
5823 fi
5824
5825 # Make sure that the compiler is able to generate an executable.  If it
5826 # can't, we are probably in trouble.  We don't care whether we can run the
5827 # executable--we might be using a cross compiler--we only care whether it
5828 # can be created.  At this point the main configure script has set CC.
5829 we_are_ok=no
5830 echo "int main () { return 0; }" > conftest.c
5831 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5832 if test $? = 0 ; then
5833   if test -s conftest || test -s conftest.exe ; then
5834     we_are_ok=yes
5835   fi
5836 fi
5837 case $we_are_ok in
5838   no)
5839     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5840     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5841     rm -f conftest*
5842     exit 1
5843     ;;
5844 esac
5845 rm -f conftest*
5846
5847 # The Solaris /usr/ucb/cc compiler does not appear to work.
5848 case "${host}" in
5849   sparc-sun-solaris2*)
5850       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5851       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5852           could_use=
5853           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5854           if test -d /opt/cygnus/bin ; then
5855               if test "$could_use" = "" ; then
5856                   could_use="/opt/cygnus/bin"
5857               else
5858                   could_use="$could_use or /opt/cygnus/bin"
5859               fi
5860           fi
5861         if test "$could_use" = "" ; then
5862             echo "Warning: compilation may fail because you're using"
5863             echo "/usr/ucb/cc.  You should change your PATH or CC "
5864             echo "variable and rerun configure."
5865         else
5866             echo "Warning: compilation may fail because you're using"
5867             echo "/usr/ucb/cc, when you should use the C compiler from"
5868             echo "$could_use.  You should change your"
5869             echo "PATH or CC variable and rerun configure."
5870         fi
5871       fi
5872   ;;
5873 esac
5874
5875 # Decide which environment variable is used to find dynamic libraries.
5876 case "${host}" in
5877   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5878   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5879   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5880   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5881 esac
5882
5883 # On systems where the dynamic library environment variable is PATH,
5884 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5885 # built executables to PATH.
5886 if test "$RPATH_ENVVAR" = PATH; then
5887   GCC_SHLIB_SUBDIR=/shlib
5888 else
5889   GCC_SHLIB_SUBDIR=
5890 fi
5891
5892 # Record target_configdirs and the configure arguments for target and
5893 # build configuration in Makefile.
5894 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5895 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5896
5897 # Determine whether gdb needs tk/tcl or not.
5898 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5899 # and in that case we want gdb to be built without tk.  Ugh!
5900 # In fact I believe gdb is the *only* package directly dependent on tk,
5901 # so we should be able to put the 'maybe's in unconditionally and
5902 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5903 # 100% sure that that's safe though.
5904
5905 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5906 case "$enable_gdbtk" in
5907   no)
5908     GDB_TK="" ;;
5909   yes)
5910     GDB_TK="${gdb_tk}" ;;
5911   *)
5912     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5913     # distro.  Eventually someone will fix this and move Insight, nee
5914     # gdbtk to a separate directory.
5915     if test -d ${srcdir}/gdb/gdbtk ; then
5916       GDB_TK="${gdb_tk}"
5917     else
5918       GDB_TK=""
5919     fi
5920     ;;
5921 esac
5922 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5923 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5924
5925 # Strip out unwanted targets.
5926
5927 # While at that, we remove Makefiles if we were started for recursive
5928 # configuration, so that the top-level Makefile reconfigures them,
5929 # like we used to do when configure itself was recursive.
5930
5931 # Loop over modules.  $extrasub must be used with care, limiting as
5932 # much as possible the usage of range addresses.  That's because autoconf
5933 # splits the sed script to overcome limits in the number of commands,
5934 # and relying on carefully-timed sed passes may turn out to be very hard
5935 # to maintain later.  In this particular case, you just have to be careful
5936 # not to nest @if/@endif pairs, because configure will not warn you at all.
5937
5938 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5939 if test "${enable_bootstrap+set}" = set; then
5940   enableval="$enable_bootstrap"
5941
5942 else
5943   enable_bootstrap=default
5944 fi;
5945
5946 # Issue errors and warnings for invalid/strange bootstrap combinations.
5947 case "$configdirs" in
5948   *gcc*) have_compiler=yes ;;
5949   *) have_compiler=no ;;
5950 esac
5951
5952 case "$have_compiler:$host:$target:$enable_bootstrap" in
5953   *:*:*:no) ;;
5954
5955   # Default behavior.  Enable bootstrap if we have a compiler
5956   # and we are in a native configuration.
5957   yes:$build:$build:default)
5958     enable_bootstrap=yes ;;
5959
5960   *:*:*:default)
5961     enable_bootstrap=no ;;
5962
5963   # We have a compiler and we are in a native configuration, bootstrap is ok
5964   yes:$build:$build:yes)
5965     ;;
5966
5967   # Other configurations, but we have a compiler.  Assume the user knows
5968   # what he's doing.
5969   yes:*:*:yes)
5970     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5971 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5972     ;;
5973
5974   # No compiler: if they passed --enable-bootstrap explicitly, fail
5975   no:*:*:yes)
5976     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5977 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5978    { (exit 1); exit 1; }; } ;;
5979
5980   # Fail if wrong command line
5981   *)
5982     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5983 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5984    { (exit 1); exit 1; }; }
5985     ;;
5986 esac
5987
5988 # Adjust the toplevel makefile according to whether bootstrap was selected.
5989 case "$enable_bootstrap" in
5990   yes)
5991     bootstrap_suffix=bootstrap ;;
5992   no)
5993     bootstrap_suffix=no-bootstrap ;;
5994 esac
5995
5996 for module in ${build_configdirs} ; do
5997   if test -z "${no_recursion}" \
5998      && test -f ${build_subdir}/${module}/Makefile; then
5999     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6000     rm -f ${build_subdir}/${module}/Makefile
6001   fi
6002   extrasub="$extrasub
6003 /^@if build-$module\$/d
6004 /^@endif build-$module\$/d
6005 /^@if build-$module-$bootstrap_suffix\$/d
6006 /^@endif build-$module-$bootstrap_suffix\$/d"
6007 done
6008 for module in ${configdirs} ; do
6009   if test -z "${no_recursion}"; then
6010     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6011       if test -f ${file}; then
6012         echo 1>&2 "*** removing ${file} to force reconfigure"
6013         rm -f ${file}
6014       fi
6015     done
6016   fi
6017   extrasub="$extrasub
6018 /^@if $module\$/d
6019 /^@endif $module\$/d
6020 /^@if $module-$bootstrap_suffix\$/d
6021 /^@endif $module-$bootstrap_suffix\$/d"
6022 done
6023 for module in ${target_configdirs} ; do
6024   if test -z "${no_recursion}" \
6025      && test -f ${target_subdir}/${module}/Makefile; then
6026     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6027     rm -f ${target_subdir}/${module}/Makefile
6028   fi
6029   extrasub="$extrasub
6030 /^@if target-$module\$/d
6031 /^@endif target-$module\$/d
6032 /^@if target-$module-$bootstrap_suffix\$/d
6033 /^@endif target-$module-$bootstrap_suffix\$/d"
6034 done
6035
6036 extrasub="$extrasub
6037 /^@if /,/^@endif /d"
6038
6039 # Create the serialization dependencies.  This uses a temporary file.
6040
6041 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6042 if test "${enable_serial_configure+set}" = set; then
6043   enableval="$enable_serial_configure"
6044
6045 fi;
6046
6047 case ${enable_serial_configure} in
6048   yes)
6049     enable_serial_build_configure=yes
6050     enable_serial_host_configure=yes
6051     enable_serial_target_configure=yes
6052     ;;
6053 esac
6054
6055 # These force 'configure's to be done one at a time, to avoid problems
6056 # with contention over a shared config.cache.
6057 rm -f serdep.tmp
6058 echo '# serdep.tmp' > serdep.tmp
6059 olditem=
6060 test "x${enable_serial_build_configure}" = xyes &&
6061 for item in ${build_configdirs} ; do
6062   case ${olditem} in
6063     "") ;;
6064     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6065   esac
6066   olditem=${item}
6067 done
6068 olditem=
6069 test "x${enable_serial_host_configure}" = xyes &&
6070 for item in ${configdirs} ; do
6071   case ${olditem} in
6072     "") ;;
6073     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6074   esac
6075   olditem=${item}
6076 done
6077 olditem=
6078 test "x${enable_serial_target_configure}" = xyes &&
6079 for item in ${target_configdirs} ; do
6080   case ${olditem} in
6081     "") ;;
6082     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6083   esac
6084   olditem=${item}
6085 done
6086 serialization_dependencies=serdep.tmp
6087
6088
6089 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6090 # target, nonopt, and variable assignments.  These are the ones we
6091 # might not want to pass down to subconfigures.  Also strip
6092 # program-prefix, program-suffix, and program-transform-name, so that
6093 # we can pass down a consistent program-transform-name.
6094 baseargs=
6095 keep_next=no
6096 skip_next=no
6097 eval "set -- $ac_configure_args"
6098 for ac_arg
6099 do
6100   if test X"$skip_next" = X"yes"; then
6101     skip_next=no
6102     continue
6103   fi
6104   if test X"$keep_next" = X"yes"; then
6105     case $ac_arg in
6106       *\'*)
6107         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6108     esac
6109     baseargs="$baseargs '$ac_arg'"
6110     keep_next=no
6111     continue
6112   fi
6113
6114   # Handle separated arguments.  Based on the logic generated by
6115   # autoconf 2.59.
6116   case $ac_arg in
6117     *=* | --config-cache | -C | -disable-* | --disable-* \
6118       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6119       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6120       | -with-* | --with-* | -without-* | --without-* | --x)
6121       separate_arg=no
6122       ;;
6123     -*)
6124       separate_arg=yes
6125       ;;
6126     *)
6127       separate_arg=no
6128       ;;
6129   esac
6130
6131   case "$ac_arg" in
6132     --no*)
6133       continue
6134       ;;
6135     --c* | \
6136     --sr* | \
6137     --ho* | \
6138     --bu* | \
6139     --t* | \
6140     --program-* | \
6141     -cache_file* | \
6142     -srcdir* | \
6143     -host* | \
6144     -build* | \
6145     -target* | \
6146     -program-prefix* | \
6147     -program-suffix* | \
6148     -program-transform-name* )
6149       skip_next=$separate_arg
6150       continue
6151       ;;
6152     -*)
6153       # An option.  Add it.
6154       case $ac_arg in
6155         *\'*)
6156           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6157       esac
6158       baseargs="$baseargs '$ac_arg'"
6159       keep_next=$separate_arg
6160       ;;
6161     *)
6162       # Either a variable assignment, or a nonopt (triplet).  Don't
6163       # pass it down; let the Makefile handle this.
6164       continue
6165       ;;
6166   esac
6167 done
6168 # Remove the initial space we just introduced and, as these will be
6169 # expanded by make, quote '$'.
6170 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6171
6172 # Add in --program-transform-name, after --program-prefix and
6173 # --program-suffix have been applied to it.  Autoconf has already
6174 # doubled dollar signs and backslashes in program_transform_name; we want
6175 # the backslashes un-doubled, and then the entire thing wrapped in single
6176 # quotes, because this will be expanded first by make and then by the shell.
6177 # Also, because we want to override the logic in subdir configure scripts to
6178 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6179 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6180 ${program_transform_name}
6181 EOF_SED
6182 gcc_transform_name=`cat conftestsed.out`
6183 rm -f conftestsed.out
6184 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6185 if test "$silent" = yes; then
6186   baseargs="$baseargs --silent"
6187 fi
6188
6189 # For the build-side libraries, we just need to pretend we're native,
6190 # and not use the same cache file.  Multilibs are neither needed nor
6191 # desired.
6192 build_configargs="--cache-file=../config.cache ${baseargs}"
6193
6194 # For host modules, accept cache file option, or specification as blank.
6195 case "${cache_file}" in
6196 "") # empty
6197   cache_file_option="" ;;
6198 /* | [A-Za-z]:[\\/]* ) # absolute path
6199   cache_file_option="--cache-file=${cache_file}" ;;
6200 *) # relative path
6201   cache_file_option="--cache-file=../${cache_file}" ;;
6202 esac
6203
6204 # Host dirs don't like to share a cache file either, horribly enough.
6205 # This seems to be due to autoconf 2.5x stupidity.
6206 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6207
6208 target_configargs=${baseargs}
6209
6210 # Passing a --with-cross-host argument lets the target libraries know
6211 # whether they are being built with a cross-compiler or being built
6212 # native.  However, it would be better to use other mechanisms to make the
6213 # sorts of decisions they want to make on this basis.  Please consider
6214 # this option to be deprecated.  FIXME.
6215 if test x${is_cross_compiler} = xyes ; then
6216   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6217 fi
6218
6219 # Default to --enable-multilib.
6220 if test x${enable_multilib} = x ; then
6221   target_configargs="--enable-multilib ${target_configargs}"
6222 fi
6223
6224 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6225 # changed from the earlier setting of with_newlib.
6226 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6227   target_configargs="--with-newlib ${target_configargs}"
6228 fi
6229
6230 # Different target subdirs use different values of certain variables
6231 # (notably CXX).  Worse, multilibs use *lots* of different values.
6232 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6233 # it doesn't automatically accept command-line overrides of them.
6234 # This means it's not safe for target subdirs to share a cache file,
6235 # which is disgusting, but there you have it.  Hopefully this can be
6236 # fixed in future.  It's still worthwhile to use a cache file for each
6237 # directory.  I think.
6238
6239 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6240 # We need to pass --target, as newer autoconf's requires consistency
6241 # for target_alias and gcc doesn't manage it consistently.
6242 target_configargs="--cache-file=./config.cache ${target_configargs}"
6243
6244 FLAGS_FOR_TARGET=
6245 case " $target_configdirs " in
6246  *" newlib "*)
6247   case " $target_configargs " in
6248   *" --with-newlib "*)
6249    case "$target" in
6250    *-cygwin*)
6251      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' ;;
6252    esac
6253
6254    # If we're not building GCC, don't discard standard headers.
6255    if test -d ${srcdir}/gcc; then
6256      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6257
6258      if test "${build}" != "${host}"; then
6259        # On Canadian crosses, CC_FOR_TARGET will have already been set
6260        # by `configure', so we won't have an opportunity to add -Bgcc/
6261        # to it.  This is right: we don't want to search that directory
6262        # for binaries, but we want the header files in there, so add
6263        # them explicitly.
6264        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6265
6266        # Someone might think of using the pre-installed headers on
6267        # Canadian crosses, in case the installed compiler is not fully
6268        # compatible with the compiler being built.  In this case, it
6269        # would be better to flag an error than risking having
6270        # incompatible object files being constructed.  We can't
6271        # guarantee that an error will be flagged, but let's hope the
6272        # compiler will do it, when presented with incompatible header
6273        # files.
6274      fi
6275    fi
6276
6277    case "${target}-${is_cross_compiler}" in
6278    i[3456789]86-*-linux*-no)
6279       # Here host == target, so we don't need to build gcc,
6280       # so we don't want to discard standard headers.
6281       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6282       ;;
6283    *)
6284       # If we're building newlib, use its generic headers last, but search
6285       # for any libc-related directories first (so make it the last -B
6286       # switch).
6287       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6288
6289       # If we're building libgloss, find the startup file, simulator library
6290       # and linker script.
6291       case " $target_configdirs " in
6292         *" libgloss "*)
6293         # Look for startup file, simulator library and maybe linker script.
6294         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6295         # Look for libnosys.a in case the target needs it.
6296         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6297         # Most targets have the linker script in the source directory.
6298         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6299         ;;
6300       esac
6301       ;;
6302    esac
6303    ;;
6304   esac
6305   ;;
6306 esac
6307 case "$target" in
6308 *-mingw*)
6309   # Can't be handled as Cygwin above since Mingw does not use newlib.
6310   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' ;;
6311 esac
6312
6313 # Allow the user to override the flags for
6314 # our build compiler if desired.
6315 if test x"${build}" = x"${host}" ; then
6316   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6317   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6318   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6319 fi
6320
6321 # On Canadian crosses, we'll be searching the right directories for
6322 # the previously-installed cross compiler, so don't bother to add
6323 # flags for directories within the install tree of the compiler
6324 # being built; programs in there won't even run.
6325 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6326   # Search for pre-installed headers if nothing else fits.
6327   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6328 fi
6329
6330 if test "x${use_gnu_ld}" = x &&
6331    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6332   # Arrange for us to find uninstalled linker scripts.
6333   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6334 fi
6335
6336 # Search for other target-specific linker scripts and such.
6337 case "${target}" in
6338   mep*)
6339     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6340     ;;
6341 esac
6342
6343 # Makefile fragments.
6344 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6345 do
6346   eval fragval=\$$frag
6347   if test $fragval != /dev/null; then
6348     eval $frag=${srcdir}/$fragval
6349   fi
6350 done
6351
6352
6353
6354
6355
6356 # Miscellanea: directories, flags, etc.
6357
6358
6359
6360
6361
6362
6363
6364
6365 # Build module lists & subconfigure args.
6366
6367
6368
6369 # Host module lists & subconfigure args.
6370
6371
6372
6373 # Target module lists & subconfigure args.
6374
6375
6376
6377 # Build tools.
6378
6379
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395 # Generate default definitions for YACC, M4, LEX and other programs that run
6396 # on the build machine.  These are used if the Makefile can't locate these
6397 # programs in objdir.
6398 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6399
6400 for ac_prog in 'bison -y' byacc yacc
6401 do
6402   # Extract the first word of "$ac_prog", so it can be a program name with args.
6403 set dummy $ac_prog; ac_word=$2
6404 echo "$as_me:$LINENO: checking for $ac_word" >&5
6405 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6406 if test "${ac_cv_prog_YACC+set}" = set; then
6407   echo $ECHO_N "(cached) $ECHO_C" >&6
6408 else
6409   if test -n "$YACC"; then
6410   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6411 else
6412 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6413 for as_dir in $PATH
6414 do
6415   IFS=$as_save_IFS
6416   test -z "$as_dir" && as_dir=.
6417   for ac_exec_ext in '' $ac_executable_extensions; do
6418   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6419     ac_cv_prog_YACC="$ac_prog"
6420     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6421     break 2
6422   fi
6423 done
6424 done
6425
6426 fi
6427 fi
6428 YACC=$ac_cv_prog_YACC
6429 if test -n "$YACC"; then
6430   echo "$as_me:$LINENO: result: $YACC" >&5
6431 echo "${ECHO_T}$YACC" >&6
6432 else
6433   echo "$as_me:$LINENO: result: no" >&5
6434 echo "${ECHO_T}no" >&6
6435 fi
6436
6437   test -n "$YACC" && break
6438 done
6439 test -n "$YACC" || YACC="$MISSING bison -y"
6440
6441 case " $build_configdirs " in
6442   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6443   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6444 esac
6445
6446 for ac_prog in bison
6447 do
6448   # Extract the first word of "$ac_prog", so it can be a program name with args.
6449 set dummy $ac_prog; ac_word=$2
6450 echo "$as_me:$LINENO: checking for $ac_word" >&5
6451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6452 if test "${ac_cv_prog_BISON+set}" = set; then
6453   echo $ECHO_N "(cached) $ECHO_C" >&6
6454 else
6455   if test -n "$BISON"; then
6456   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6457 else
6458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6459 for as_dir in $PATH
6460 do
6461   IFS=$as_save_IFS
6462   test -z "$as_dir" && as_dir=.
6463   for ac_exec_ext in '' $ac_executable_extensions; do
6464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6465     ac_cv_prog_BISON="$ac_prog"
6466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6467     break 2
6468   fi
6469 done
6470 done
6471
6472 fi
6473 fi
6474 BISON=$ac_cv_prog_BISON
6475 if test -n "$BISON"; then
6476   echo "$as_me:$LINENO: result: $BISON" >&5
6477 echo "${ECHO_T}$BISON" >&6
6478 else
6479   echo "$as_me:$LINENO: result: no" >&5
6480 echo "${ECHO_T}no" >&6
6481 fi
6482
6483   test -n "$BISON" && break
6484 done
6485 test -n "$BISON" || BISON="$MISSING bison"
6486
6487 case " $build_configdirs " in
6488   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6489 esac
6490
6491 for ac_prog in gm4 gnum4 m4
6492 do
6493   # Extract the first word of "$ac_prog", so it can be a program name with args.
6494 set dummy $ac_prog; ac_word=$2
6495 echo "$as_me:$LINENO: checking for $ac_word" >&5
6496 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6497 if test "${ac_cv_prog_M4+set}" = set; then
6498   echo $ECHO_N "(cached) $ECHO_C" >&6
6499 else
6500   if test -n "$M4"; then
6501   ac_cv_prog_M4="$M4" # Let the user override the test.
6502 else
6503 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6504 for as_dir in $PATH
6505 do
6506   IFS=$as_save_IFS
6507   test -z "$as_dir" && as_dir=.
6508   for ac_exec_ext in '' $ac_executable_extensions; do
6509   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6510     ac_cv_prog_M4="$ac_prog"
6511     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6512     break 2
6513   fi
6514 done
6515 done
6516
6517 fi
6518 fi
6519 M4=$ac_cv_prog_M4
6520 if test -n "$M4"; then
6521   echo "$as_me:$LINENO: result: $M4" >&5
6522 echo "${ECHO_T}$M4" >&6
6523 else
6524   echo "$as_me:$LINENO: result: no" >&5
6525 echo "${ECHO_T}no" >&6
6526 fi
6527
6528   test -n "$M4" && break
6529 done
6530 test -n "$M4" || M4="$MISSING m4"
6531
6532 case " $build_configdirs " in
6533   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6534 esac
6535
6536 for ac_prog in flex lex
6537 do
6538   # Extract the first word of "$ac_prog", so it can be a program name with args.
6539 set dummy $ac_prog; ac_word=$2
6540 echo "$as_me:$LINENO: checking for $ac_word" >&5
6541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6542 if test "${ac_cv_prog_LEX+set}" = set; then
6543   echo $ECHO_N "(cached) $ECHO_C" >&6
6544 else
6545   if test -n "$LEX"; then
6546   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6547 else
6548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6549 for as_dir in $PATH
6550 do
6551   IFS=$as_save_IFS
6552   test -z "$as_dir" && as_dir=.
6553   for ac_exec_ext in '' $ac_executable_extensions; do
6554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6555     ac_cv_prog_LEX="$ac_prog"
6556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6557     break 2
6558   fi
6559 done
6560 done
6561
6562 fi
6563 fi
6564 LEX=$ac_cv_prog_LEX
6565 if test -n "$LEX"; then
6566   echo "$as_me:$LINENO: result: $LEX" >&5
6567 echo "${ECHO_T}$LEX" >&6
6568 else
6569   echo "$as_me:$LINENO: result: no" >&5
6570 echo "${ECHO_T}no" >&6
6571 fi
6572
6573   test -n "$LEX" && break
6574 done
6575 test -n "$LEX" || LEX="$MISSING flex"
6576
6577 case " $build_configdirs " in
6578   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6579   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6580 esac
6581
6582 for ac_prog in flex
6583 do
6584   # Extract the first word of "$ac_prog", so it can be a program name with args.
6585 set dummy $ac_prog; ac_word=$2
6586 echo "$as_me:$LINENO: checking for $ac_word" >&5
6587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6588 if test "${ac_cv_prog_FLEX+set}" = set; then
6589   echo $ECHO_N "(cached) $ECHO_C" >&6
6590 else
6591   if test -n "$FLEX"; then
6592   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6593 else
6594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6595 for as_dir in $PATH
6596 do
6597   IFS=$as_save_IFS
6598   test -z "$as_dir" && as_dir=.
6599   for ac_exec_ext in '' $ac_executable_extensions; do
6600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6601     ac_cv_prog_FLEX="$ac_prog"
6602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6603     break 2
6604   fi
6605 done
6606 done
6607
6608 fi
6609 fi
6610 FLEX=$ac_cv_prog_FLEX
6611 if test -n "$FLEX"; then
6612   echo "$as_me:$LINENO: result: $FLEX" >&5
6613 echo "${ECHO_T}$FLEX" >&6
6614 else
6615   echo "$as_me:$LINENO: result: no" >&5
6616 echo "${ECHO_T}no" >&6
6617 fi
6618
6619   test -n "$FLEX" && break
6620 done
6621 test -n "$FLEX" || FLEX="$MISSING flex"
6622
6623 case " $build_configdirs " in
6624   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6625 esac
6626
6627 for ac_prog in makeinfo
6628 do
6629   # Extract the first word of "$ac_prog", so it can be a program name with args.
6630 set dummy $ac_prog; ac_word=$2
6631 echo "$as_me:$LINENO: checking for $ac_word" >&5
6632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6633 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6634   echo $ECHO_N "(cached) $ECHO_C" >&6
6635 else
6636   if test -n "$MAKEINFO"; then
6637   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6638 else
6639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6640 for as_dir in $PATH
6641 do
6642   IFS=$as_save_IFS
6643   test -z "$as_dir" && as_dir=.
6644   for ac_exec_ext in '' $ac_executable_extensions; do
6645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6646     ac_cv_prog_MAKEINFO="$ac_prog"
6647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6648     break 2
6649   fi
6650 done
6651 done
6652
6653 fi
6654 fi
6655 MAKEINFO=$ac_cv_prog_MAKEINFO
6656 if test -n "$MAKEINFO"; then
6657   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6658 echo "${ECHO_T}$MAKEINFO" >&6
6659 else
6660   echo "$as_me:$LINENO: result: no" >&5
6661 echo "${ECHO_T}no" >&6
6662 fi
6663
6664   test -n "$MAKEINFO" && break
6665 done
6666 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6667
6668 case " $build_configdirs " in
6669   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6670   *)
6671
6672     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6673     # higher, else we use the "missing" dummy.
6674     if ${MAKEINFO} --version \
6675        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6676       :
6677     else
6678       MAKEINFO="$MISSING makeinfo"
6679     fi
6680     ;;
6681
6682 esac
6683
6684 # FIXME: expect and dejagnu may become build tools?
6685
6686 for ac_prog in expect
6687 do
6688   # Extract the first word of "$ac_prog", so it can be a program name with args.
6689 set dummy $ac_prog; ac_word=$2
6690 echo "$as_me:$LINENO: checking for $ac_word" >&5
6691 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6692 if test "${ac_cv_prog_EXPECT+set}" = set; then
6693   echo $ECHO_N "(cached) $ECHO_C" >&6
6694 else
6695   if test -n "$EXPECT"; then
6696   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6697 else
6698 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6699 for as_dir in $PATH
6700 do
6701   IFS=$as_save_IFS
6702   test -z "$as_dir" && as_dir=.
6703   for ac_exec_ext in '' $ac_executable_extensions; do
6704   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6705     ac_cv_prog_EXPECT="$ac_prog"
6706     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6707     break 2
6708   fi
6709 done
6710 done
6711
6712 fi
6713 fi
6714 EXPECT=$ac_cv_prog_EXPECT
6715 if test -n "$EXPECT"; then
6716   echo "$as_me:$LINENO: result: $EXPECT" >&5
6717 echo "${ECHO_T}$EXPECT" >&6
6718 else
6719   echo "$as_me:$LINENO: result: no" >&5
6720 echo "${ECHO_T}no" >&6
6721 fi
6722
6723   test -n "$EXPECT" && break
6724 done
6725 test -n "$EXPECT" || EXPECT="expect"
6726
6727 case " $configdirs " in
6728   *" expect "*)
6729     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6730     ;;
6731 esac
6732
6733 for ac_prog in runtest
6734 do
6735   # Extract the first word of "$ac_prog", so it can be a program name with args.
6736 set dummy $ac_prog; ac_word=$2
6737 echo "$as_me:$LINENO: checking for $ac_word" >&5
6738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6739 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6740   echo $ECHO_N "(cached) $ECHO_C" >&6
6741 else
6742   if test -n "$RUNTEST"; then
6743   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6744 else
6745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6746 for as_dir in $PATH
6747 do
6748   IFS=$as_save_IFS
6749   test -z "$as_dir" && as_dir=.
6750   for ac_exec_ext in '' $ac_executable_extensions; do
6751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6752     ac_cv_prog_RUNTEST="$ac_prog"
6753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6754     break 2
6755   fi
6756 done
6757 done
6758
6759 fi
6760 fi
6761 RUNTEST=$ac_cv_prog_RUNTEST
6762 if test -n "$RUNTEST"; then
6763   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6764 echo "${ECHO_T}$RUNTEST" >&6
6765 else
6766   echo "$as_me:$LINENO: result: no" >&5
6767 echo "${ECHO_T}no" >&6
6768 fi
6769
6770   test -n "$RUNTEST" && break
6771 done
6772 test -n "$RUNTEST" || RUNTEST="runtest"
6773
6774 case " $configdirs " in
6775   *" dejagnu "*)
6776     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6777     ;;
6778 esac
6779
6780
6781 # Host tools.
6782 ncn_tool_prefix=
6783 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6784 ncn_target_tool_prefix=
6785 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6786
6787
6788
6789 if test -n "$AR"; then
6790   ac_cv_prog_AR=$AR
6791 elif test -n "$ac_cv_prog_AR"; then
6792   AR=$ac_cv_prog_AR
6793 fi
6794
6795 if test -n "$ac_cv_prog_AR"; then
6796   for ncn_progname in ar; do
6797     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6798 set dummy ${ncn_progname}; ac_word=$2
6799 echo "$as_me:$LINENO: checking for $ac_word" >&5
6800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6801 if test "${ac_cv_prog_AR+set}" = set; then
6802   echo $ECHO_N "(cached) $ECHO_C" >&6
6803 else
6804   if test -n "$AR"; then
6805   ac_cv_prog_AR="$AR" # Let the user override the test.
6806 else
6807 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6808 for as_dir in $PATH
6809 do
6810   IFS=$as_save_IFS
6811   test -z "$as_dir" && as_dir=.
6812   for ac_exec_ext in '' $ac_executable_extensions; do
6813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6814     ac_cv_prog_AR="${ncn_progname}"
6815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6816     break 2
6817   fi
6818 done
6819 done
6820
6821 fi
6822 fi
6823 AR=$ac_cv_prog_AR
6824 if test -n "$AR"; then
6825   echo "$as_me:$LINENO: result: $AR" >&5
6826 echo "${ECHO_T}$AR" >&6
6827 else
6828   echo "$as_me:$LINENO: result: no" >&5
6829 echo "${ECHO_T}no" >&6
6830 fi
6831
6832   done
6833 fi
6834
6835 for ncn_progname in ar; do
6836   if test -n "$ncn_tool_prefix"; then
6837     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6838 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6839 echo "$as_me:$LINENO: checking for $ac_word" >&5
6840 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6841 if test "${ac_cv_prog_AR+set}" = set; then
6842   echo $ECHO_N "(cached) $ECHO_C" >&6
6843 else
6844   if test -n "$AR"; then
6845   ac_cv_prog_AR="$AR" # Let the user override the test.
6846 else
6847 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6848 for as_dir in $PATH
6849 do
6850   IFS=$as_save_IFS
6851   test -z "$as_dir" && as_dir=.
6852   for ac_exec_ext in '' $ac_executable_extensions; do
6853   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6854     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6855     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6856     break 2
6857   fi
6858 done
6859 done
6860
6861 fi
6862 fi
6863 AR=$ac_cv_prog_AR
6864 if test -n "$AR"; then
6865   echo "$as_me:$LINENO: result: $AR" >&5
6866 echo "${ECHO_T}$AR" >&6
6867 else
6868   echo "$as_me:$LINENO: result: no" >&5
6869 echo "${ECHO_T}no" >&6
6870 fi
6871
6872   fi
6873   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6874     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6875 set dummy ${ncn_progname}; ac_word=$2
6876 echo "$as_me:$LINENO: checking for $ac_word" >&5
6877 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6878 if test "${ac_cv_prog_AR+set}" = set; then
6879   echo $ECHO_N "(cached) $ECHO_C" >&6
6880 else
6881   if test -n "$AR"; then
6882   ac_cv_prog_AR="$AR" # Let the user override the test.
6883 else
6884 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6885 for as_dir in $PATH
6886 do
6887   IFS=$as_save_IFS
6888   test -z "$as_dir" && as_dir=.
6889   for ac_exec_ext in '' $ac_executable_extensions; do
6890   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6891     ac_cv_prog_AR="${ncn_progname}"
6892     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6893     break 2
6894   fi
6895 done
6896 done
6897
6898 fi
6899 fi
6900 AR=$ac_cv_prog_AR
6901 if test -n "$AR"; then
6902   echo "$as_me:$LINENO: result: $AR" >&5
6903 echo "${ECHO_T}$AR" >&6
6904 else
6905   echo "$as_me:$LINENO: result: no" >&5
6906 echo "${ECHO_T}no" >&6
6907 fi
6908
6909   fi
6910   test -n "$ac_cv_prog_AR" && break
6911 done
6912
6913 if test -z "$ac_cv_prog_AR" ; then
6914   set dummy ar
6915   if test $build = $host ; then
6916     AR="$2"
6917   else
6918     AR="${ncn_tool_prefix}$2"
6919   fi
6920 fi
6921
6922
6923
6924 if test -n "$AS"; then
6925   ac_cv_prog_AS=$AS
6926 elif test -n "$ac_cv_prog_AS"; then
6927   AS=$ac_cv_prog_AS
6928 fi
6929
6930 if test -n "$ac_cv_prog_AS"; then
6931   for ncn_progname in as; do
6932     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6933 set dummy ${ncn_progname}; ac_word=$2
6934 echo "$as_me:$LINENO: checking for $ac_word" >&5
6935 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6936 if test "${ac_cv_prog_AS+set}" = set; then
6937   echo $ECHO_N "(cached) $ECHO_C" >&6
6938 else
6939   if test -n "$AS"; then
6940   ac_cv_prog_AS="$AS" # Let the user override the test.
6941 else
6942 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6943 for as_dir in $PATH
6944 do
6945   IFS=$as_save_IFS
6946   test -z "$as_dir" && as_dir=.
6947   for ac_exec_ext in '' $ac_executable_extensions; do
6948   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6949     ac_cv_prog_AS="${ncn_progname}"
6950     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6951     break 2
6952   fi
6953 done
6954 done
6955
6956 fi
6957 fi
6958 AS=$ac_cv_prog_AS
6959 if test -n "$AS"; then
6960   echo "$as_me:$LINENO: result: $AS" >&5
6961 echo "${ECHO_T}$AS" >&6
6962 else
6963   echo "$as_me:$LINENO: result: no" >&5
6964 echo "${ECHO_T}no" >&6
6965 fi
6966
6967   done
6968 fi
6969
6970 for ncn_progname in as; do
6971   if test -n "$ncn_tool_prefix"; then
6972     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6973 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6974 echo "$as_me:$LINENO: checking for $ac_word" >&5
6975 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6976 if test "${ac_cv_prog_AS+set}" = set; then
6977   echo $ECHO_N "(cached) $ECHO_C" >&6
6978 else
6979   if test -n "$AS"; then
6980   ac_cv_prog_AS="$AS" # Let the user override the test.
6981 else
6982 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6983 for as_dir in $PATH
6984 do
6985   IFS=$as_save_IFS
6986   test -z "$as_dir" && as_dir=.
6987   for ac_exec_ext in '' $ac_executable_extensions; do
6988   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6989     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6990     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6991     break 2
6992   fi
6993 done
6994 done
6995
6996 fi
6997 fi
6998 AS=$ac_cv_prog_AS
6999 if test -n "$AS"; then
7000   echo "$as_me:$LINENO: result: $AS" >&5
7001 echo "${ECHO_T}$AS" >&6
7002 else
7003   echo "$as_me:$LINENO: result: no" >&5
7004 echo "${ECHO_T}no" >&6
7005 fi
7006
7007   fi
7008   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7009     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7010 set dummy ${ncn_progname}; ac_word=$2
7011 echo "$as_me:$LINENO: checking for $ac_word" >&5
7012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7013 if test "${ac_cv_prog_AS+set}" = set; then
7014   echo $ECHO_N "(cached) $ECHO_C" >&6
7015 else
7016   if test -n "$AS"; then
7017   ac_cv_prog_AS="$AS" # Let the user override the test.
7018 else
7019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7020 for as_dir in $PATH
7021 do
7022   IFS=$as_save_IFS
7023   test -z "$as_dir" && as_dir=.
7024   for ac_exec_ext in '' $ac_executable_extensions; do
7025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7026     ac_cv_prog_AS="${ncn_progname}"
7027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7028     break 2
7029   fi
7030 done
7031 done
7032
7033 fi
7034 fi
7035 AS=$ac_cv_prog_AS
7036 if test -n "$AS"; then
7037   echo "$as_me:$LINENO: result: $AS" >&5
7038 echo "${ECHO_T}$AS" >&6
7039 else
7040   echo "$as_me:$LINENO: result: no" >&5
7041 echo "${ECHO_T}no" >&6
7042 fi
7043
7044   fi
7045   test -n "$ac_cv_prog_AS" && break
7046 done
7047
7048 if test -z "$ac_cv_prog_AS" ; then
7049   set dummy as
7050   if test $build = $host ; then
7051     AS="$2"
7052   else
7053     AS="${ncn_tool_prefix}$2"
7054   fi
7055 fi
7056
7057
7058
7059 if test -n "$DLLTOOL"; then
7060   ac_cv_prog_DLLTOOL=$DLLTOOL
7061 elif test -n "$ac_cv_prog_DLLTOOL"; then
7062   DLLTOOL=$ac_cv_prog_DLLTOOL
7063 fi
7064
7065 if test -n "$ac_cv_prog_DLLTOOL"; then
7066   for ncn_progname in dlltool; do
7067     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7068 set dummy ${ncn_progname}; ac_word=$2
7069 echo "$as_me:$LINENO: checking for $ac_word" >&5
7070 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7071 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7072   echo $ECHO_N "(cached) $ECHO_C" >&6
7073 else
7074   if test -n "$DLLTOOL"; then
7075   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7076 else
7077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7078 for as_dir in $PATH
7079 do
7080   IFS=$as_save_IFS
7081   test -z "$as_dir" && as_dir=.
7082   for ac_exec_ext in '' $ac_executable_extensions; do
7083   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7084     ac_cv_prog_DLLTOOL="${ncn_progname}"
7085     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7086     break 2
7087   fi
7088 done
7089 done
7090
7091 fi
7092 fi
7093 DLLTOOL=$ac_cv_prog_DLLTOOL
7094 if test -n "$DLLTOOL"; then
7095   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7096 echo "${ECHO_T}$DLLTOOL" >&6
7097 else
7098   echo "$as_me:$LINENO: result: no" >&5
7099 echo "${ECHO_T}no" >&6
7100 fi
7101
7102   done
7103 fi
7104
7105 for ncn_progname in dlltool; do
7106   if test -n "$ncn_tool_prefix"; then
7107     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7108 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7109 echo "$as_me:$LINENO: checking for $ac_word" >&5
7110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7111 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7112   echo $ECHO_N "(cached) $ECHO_C" >&6
7113 else
7114   if test -n "$DLLTOOL"; then
7115   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7116 else
7117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7118 for as_dir in $PATH
7119 do
7120   IFS=$as_save_IFS
7121   test -z "$as_dir" && as_dir=.
7122   for ac_exec_ext in '' $ac_executable_extensions; do
7123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7124     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7126     break 2
7127   fi
7128 done
7129 done
7130
7131 fi
7132 fi
7133 DLLTOOL=$ac_cv_prog_DLLTOOL
7134 if test -n "$DLLTOOL"; then
7135   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7136 echo "${ECHO_T}$DLLTOOL" >&6
7137 else
7138   echo "$as_me:$LINENO: result: no" >&5
7139 echo "${ECHO_T}no" >&6
7140 fi
7141
7142   fi
7143   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7144     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7145 set dummy ${ncn_progname}; ac_word=$2
7146 echo "$as_me:$LINENO: checking for $ac_word" >&5
7147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7148 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7149   echo $ECHO_N "(cached) $ECHO_C" >&6
7150 else
7151   if test -n "$DLLTOOL"; then
7152   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7153 else
7154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7155 for as_dir in $PATH
7156 do
7157   IFS=$as_save_IFS
7158   test -z "$as_dir" && as_dir=.
7159   for ac_exec_ext in '' $ac_executable_extensions; do
7160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7161     ac_cv_prog_DLLTOOL="${ncn_progname}"
7162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7163     break 2
7164   fi
7165 done
7166 done
7167
7168 fi
7169 fi
7170 DLLTOOL=$ac_cv_prog_DLLTOOL
7171 if test -n "$DLLTOOL"; then
7172   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7173 echo "${ECHO_T}$DLLTOOL" >&6
7174 else
7175   echo "$as_me:$LINENO: result: no" >&5
7176 echo "${ECHO_T}no" >&6
7177 fi
7178
7179   fi
7180   test -n "$ac_cv_prog_DLLTOOL" && break
7181 done
7182
7183 if test -z "$ac_cv_prog_DLLTOOL" ; then
7184   set dummy dlltool
7185   if test $build = $host ; then
7186     DLLTOOL="$2"
7187   else
7188     DLLTOOL="${ncn_tool_prefix}$2"
7189   fi
7190 fi
7191
7192
7193
7194 if test -n "$LD"; then
7195   ac_cv_prog_LD=$LD
7196 elif test -n "$ac_cv_prog_LD"; then
7197   LD=$ac_cv_prog_LD
7198 fi
7199
7200 if test -n "$ac_cv_prog_LD"; then
7201   for ncn_progname in ld; do
7202     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7203 set dummy ${ncn_progname}; ac_word=$2
7204 echo "$as_me:$LINENO: checking for $ac_word" >&5
7205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7206 if test "${ac_cv_prog_LD+set}" = set; then
7207   echo $ECHO_N "(cached) $ECHO_C" >&6
7208 else
7209   if test -n "$LD"; then
7210   ac_cv_prog_LD="$LD" # Let the user override the test.
7211 else
7212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7213 for as_dir in $PATH
7214 do
7215   IFS=$as_save_IFS
7216   test -z "$as_dir" && as_dir=.
7217   for ac_exec_ext in '' $ac_executable_extensions; do
7218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7219     ac_cv_prog_LD="${ncn_progname}"
7220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7221     break 2
7222   fi
7223 done
7224 done
7225
7226 fi
7227 fi
7228 LD=$ac_cv_prog_LD
7229 if test -n "$LD"; then
7230   echo "$as_me:$LINENO: result: $LD" >&5
7231 echo "${ECHO_T}$LD" >&6
7232 else
7233   echo "$as_me:$LINENO: result: no" >&5
7234 echo "${ECHO_T}no" >&6
7235 fi
7236
7237   done
7238 fi
7239
7240 for ncn_progname in ld; do
7241   if test -n "$ncn_tool_prefix"; then
7242     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7243 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7244 echo "$as_me:$LINENO: checking for $ac_word" >&5
7245 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7246 if test "${ac_cv_prog_LD+set}" = set; then
7247   echo $ECHO_N "(cached) $ECHO_C" >&6
7248 else
7249   if test -n "$LD"; then
7250   ac_cv_prog_LD="$LD" # Let the user override the test.
7251 else
7252 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7253 for as_dir in $PATH
7254 do
7255   IFS=$as_save_IFS
7256   test -z "$as_dir" && as_dir=.
7257   for ac_exec_ext in '' $ac_executable_extensions; do
7258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7259     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7261     break 2
7262   fi
7263 done
7264 done
7265
7266 fi
7267 fi
7268 LD=$ac_cv_prog_LD
7269 if test -n "$LD"; then
7270   echo "$as_me:$LINENO: result: $LD" >&5
7271 echo "${ECHO_T}$LD" >&6
7272 else
7273   echo "$as_me:$LINENO: result: no" >&5
7274 echo "${ECHO_T}no" >&6
7275 fi
7276
7277   fi
7278   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7279     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7280 set dummy ${ncn_progname}; ac_word=$2
7281 echo "$as_me:$LINENO: checking for $ac_word" >&5
7282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7283 if test "${ac_cv_prog_LD+set}" = set; then
7284   echo $ECHO_N "(cached) $ECHO_C" >&6
7285 else
7286   if test -n "$LD"; then
7287   ac_cv_prog_LD="$LD" # Let the user override the test.
7288 else
7289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7290 for as_dir in $PATH
7291 do
7292   IFS=$as_save_IFS
7293   test -z "$as_dir" && as_dir=.
7294   for ac_exec_ext in '' $ac_executable_extensions; do
7295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7296     ac_cv_prog_LD="${ncn_progname}"
7297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7298     break 2
7299   fi
7300 done
7301 done
7302
7303 fi
7304 fi
7305 LD=$ac_cv_prog_LD
7306 if test -n "$LD"; then
7307   echo "$as_me:$LINENO: result: $LD" >&5
7308 echo "${ECHO_T}$LD" >&6
7309 else
7310   echo "$as_me:$LINENO: result: no" >&5
7311 echo "${ECHO_T}no" >&6
7312 fi
7313
7314   fi
7315   test -n "$ac_cv_prog_LD" && break
7316 done
7317
7318 if test -z "$ac_cv_prog_LD" ; then
7319   set dummy ld
7320   if test $build = $host ; then
7321     LD="$2"
7322   else
7323     LD="${ncn_tool_prefix}$2"
7324   fi
7325 fi
7326
7327
7328
7329 if test -n "$LIPO"; then
7330   ac_cv_prog_LIPO=$LIPO
7331 elif test -n "$ac_cv_prog_LIPO"; then
7332   LIPO=$ac_cv_prog_LIPO
7333 fi
7334
7335 if test -n "$ac_cv_prog_LIPO"; then
7336   for ncn_progname in lipo; do
7337     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7338 set dummy ${ncn_progname}; ac_word=$2
7339 echo "$as_me:$LINENO: checking for $ac_word" >&5
7340 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7341 if test "${ac_cv_prog_LIPO+set}" = set; then
7342   echo $ECHO_N "(cached) $ECHO_C" >&6
7343 else
7344   if test -n "$LIPO"; then
7345   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7346 else
7347 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7348 for as_dir in $PATH
7349 do
7350   IFS=$as_save_IFS
7351   test -z "$as_dir" && as_dir=.
7352   for ac_exec_ext in '' $ac_executable_extensions; do
7353   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7354     ac_cv_prog_LIPO="${ncn_progname}"
7355     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7356     break 2
7357   fi
7358 done
7359 done
7360
7361 fi
7362 fi
7363 LIPO=$ac_cv_prog_LIPO
7364 if test -n "$LIPO"; then
7365   echo "$as_me:$LINENO: result: $LIPO" >&5
7366 echo "${ECHO_T}$LIPO" >&6
7367 else
7368   echo "$as_me:$LINENO: result: no" >&5
7369 echo "${ECHO_T}no" >&6
7370 fi
7371
7372   done
7373 fi
7374
7375 for ncn_progname in lipo; do
7376   if test -n "$ncn_tool_prefix"; then
7377     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7378 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7379 echo "$as_me:$LINENO: checking for $ac_word" >&5
7380 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7381 if test "${ac_cv_prog_LIPO+set}" = set; then
7382   echo $ECHO_N "(cached) $ECHO_C" >&6
7383 else
7384   if test -n "$LIPO"; then
7385   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7386 else
7387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7388 for as_dir in $PATH
7389 do
7390   IFS=$as_save_IFS
7391   test -z "$as_dir" && as_dir=.
7392   for ac_exec_ext in '' $ac_executable_extensions; do
7393   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7394     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7395     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7396     break 2
7397   fi
7398 done
7399 done
7400
7401 fi
7402 fi
7403 LIPO=$ac_cv_prog_LIPO
7404 if test -n "$LIPO"; then
7405   echo "$as_me:$LINENO: result: $LIPO" >&5
7406 echo "${ECHO_T}$LIPO" >&6
7407 else
7408   echo "$as_me:$LINENO: result: no" >&5
7409 echo "${ECHO_T}no" >&6
7410 fi
7411
7412   fi
7413   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7414     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7415 set dummy ${ncn_progname}; ac_word=$2
7416 echo "$as_me:$LINENO: checking for $ac_word" >&5
7417 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7418 if test "${ac_cv_prog_LIPO+set}" = set; then
7419   echo $ECHO_N "(cached) $ECHO_C" >&6
7420 else
7421   if test -n "$LIPO"; then
7422   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7423 else
7424 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7425 for as_dir in $PATH
7426 do
7427   IFS=$as_save_IFS
7428   test -z "$as_dir" && as_dir=.
7429   for ac_exec_ext in '' $ac_executable_extensions; do
7430   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7431     ac_cv_prog_LIPO="${ncn_progname}"
7432     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7433     break 2
7434   fi
7435 done
7436 done
7437
7438 fi
7439 fi
7440 LIPO=$ac_cv_prog_LIPO
7441 if test -n "$LIPO"; then
7442   echo "$as_me:$LINENO: result: $LIPO" >&5
7443 echo "${ECHO_T}$LIPO" >&6
7444 else
7445   echo "$as_me:$LINENO: result: no" >&5
7446 echo "${ECHO_T}no" >&6
7447 fi
7448
7449   fi
7450   test -n "$ac_cv_prog_LIPO" && break
7451 done
7452
7453 if test -z "$ac_cv_prog_LIPO" ; then
7454   set dummy lipo
7455   if test $build = $host ; then
7456     LIPO="$2"
7457   else
7458     LIPO="${ncn_tool_prefix}$2"
7459   fi
7460 fi
7461
7462
7463
7464 if test -n "$NM"; then
7465   ac_cv_prog_NM=$NM
7466 elif test -n "$ac_cv_prog_NM"; then
7467   NM=$ac_cv_prog_NM
7468 fi
7469
7470 if test -n "$ac_cv_prog_NM"; then
7471   for ncn_progname in nm; do
7472     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7473 set dummy ${ncn_progname}; ac_word=$2
7474 echo "$as_me:$LINENO: checking for $ac_word" >&5
7475 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7476 if test "${ac_cv_prog_NM+set}" = set; then
7477   echo $ECHO_N "(cached) $ECHO_C" >&6
7478 else
7479   if test -n "$NM"; then
7480   ac_cv_prog_NM="$NM" # Let the user override the test.
7481 else
7482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7483 for as_dir in $PATH
7484 do
7485   IFS=$as_save_IFS
7486   test -z "$as_dir" && as_dir=.
7487   for ac_exec_ext in '' $ac_executable_extensions; do
7488   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7489     ac_cv_prog_NM="${ncn_progname}"
7490     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7491     break 2
7492   fi
7493 done
7494 done
7495
7496 fi
7497 fi
7498 NM=$ac_cv_prog_NM
7499 if test -n "$NM"; then
7500   echo "$as_me:$LINENO: result: $NM" >&5
7501 echo "${ECHO_T}$NM" >&6
7502 else
7503   echo "$as_me:$LINENO: result: no" >&5
7504 echo "${ECHO_T}no" >&6
7505 fi
7506
7507   done
7508 fi
7509
7510 for ncn_progname in nm; do
7511   if test -n "$ncn_tool_prefix"; then
7512     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7513 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7514 echo "$as_me:$LINENO: checking for $ac_word" >&5
7515 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7516 if test "${ac_cv_prog_NM+set}" = set; then
7517   echo $ECHO_N "(cached) $ECHO_C" >&6
7518 else
7519   if test -n "$NM"; then
7520   ac_cv_prog_NM="$NM" # Let the user override the test.
7521 else
7522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7523 for as_dir in $PATH
7524 do
7525   IFS=$as_save_IFS
7526   test -z "$as_dir" && as_dir=.
7527   for ac_exec_ext in '' $ac_executable_extensions; do
7528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7529     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7531     break 2
7532   fi
7533 done
7534 done
7535
7536 fi
7537 fi
7538 NM=$ac_cv_prog_NM
7539 if test -n "$NM"; then
7540   echo "$as_me:$LINENO: result: $NM" >&5
7541 echo "${ECHO_T}$NM" >&6
7542 else
7543   echo "$as_me:$LINENO: result: no" >&5
7544 echo "${ECHO_T}no" >&6
7545 fi
7546
7547   fi
7548   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7549     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7550 set dummy ${ncn_progname}; ac_word=$2
7551 echo "$as_me:$LINENO: checking for $ac_word" >&5
7552 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7553 if test "${ac_cv_prog_NM+set}" = set; then
7554   echo $ECHO_N "(cached) $ECHO_C" >&6
7555 else
7556   if test -n "$NM"; then
7557   ac_cv_prog_NM="$NM" # Let the user override the test.
7558 else
7559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7560 for as_dir in $PATH
7561 do
7562   IFS=$as_save_IFS
7563   test -z "$as_dir" && as_dir=.
7564   for ac_exec_ext in '' $ac_executable_extensions; do
7565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7566     ac_cv_prog_NM="${ncn_progname}"
7567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7568     break 2
7569   fi
7570 done
7571 done
7572
7573 fi
7574 fi
7575 NM=$ac_cv_prog_NM
7576 if test -n "$NM"; then
7577   echo "$as_me:$LINENO: result: $NM" >&5
7578 echo "${ECHO_T}$NM" >&6
7579 else
7580   echo "$as_me:$LINENO: result: no" >&5
7581 echo "${ECHO_T}no" >&6
7582 fi
7583
7584   fi
7585   test -n "$ac_cv_prog_NM" && break
7586 done
7587
7588 if test -z "$ac_cv_prog_NM" ; then
7589   set dummy nm
7590   if test $build = $host ; then
7591     NM="$2"
7592   else
7593     NM="${ncn_tool_prefix}$2"
7594   fi
7595 fi
7596
7597
7598
7599 if test -n "$RANLIB"; then
7600   ac_cv_prog_RANLIB=$RANLIB
7601 elif test -n "$ac_cv_prog_RANLIB"; then
7602   RANLIB=$ac_cv_prog_RANLIB
7603 fi
7604
7605 if test -n "$ac_cv_prog_RANLIB"; then
7606   for ncn_progname in ranlib; do
7607     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7608 set dummy ${ncn_progname}; ac_word=$2
7609 echo "$as_me:$LINENO: checking for $ac_word" >&5
7610 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7611 if test "${ac_cv_prog_RANLIB+set}" = set; then
7612   echo $ECHO_N "(cached) $ECHO_C" >&6
7613 else
7614   if test -n "$RANLIB"; then
7615   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7616 else
7617 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7618 for as_dir in $PATH
7619 do
7620   IFS=$as_save_IFS
7621   test -z "$as_dir" && as_dir=.
7622   for ac_exec_ext in '' $ac_executable_extensions; do
7623   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7624     ac_cv_prog_RANLIB="${ncn_progname}"
7625     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7626     break 2
7627   fi
7628 done
7629 done
7630
7631 fi
7632 fi
7633 RANLIB=$ac_cv_prog_RANLIB
7634 if test -n "$RANLIB"; then
7635   echo "$as_me:$LINENO: result: $RANLIB" >&5
7636 echo "${ECHO_T}$RANLIB" >&6
7637 else
7638   echo "$as_me:$LINENO: result: no" >&5
7639 echo "${ECHO_T}no" >&6
7640 fi
7641
7642   done
7643 fi
7644
7645 for ncn_progname in ranlib; do
7646   if test -n "$ncn_tool_prefix"; then
7647     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7648 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7649 echo "$as_me:$LINENO: checking for $ac_word" >&5
7650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7651 if test "${ac_cv_prog_RANLIB+set}" = set; then
7652   echo $ECHO_N "(cached) $ECHO_C" >&6
7653 else
7654   if test -n "$RANLIB"; then
7655   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7656 else
7657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7658 for as_dir in $PATH
7659 do
7660   IFS=$as_save_IFS
7661   test -z "$as_dir" && as_dir=.
7662   for ac_exec_ext in '' $ac_executable_extensions; do
7663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7664     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7666     break 2
7667   fi
7668 done
7669 done
7670
7671 fi
7672 fi
7673 RANLIB=$ac_cv_prog_RANLIB
7674 if test -n "$RANLIB"; then
7675   echo "$as_me:$LINENO: result: $RANLIB" >&5
7676 echo "${ECHO_T}$RANLIB" >&6
7677 else
7678   echo "$as_me:$LINENO: result: no" >&5
7679 echo "${ECHO_T}no" >&6
7680 fi
7681
7682   fi
7683   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7684     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7685 set dummy ${ncn_progname}; ac_word=$2
7686 echo "$as_me:$LINENO: checking for $ac_word" >&5
7687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7688 if test "${ac_cv_prog_RANLIB+set}" = set; then
7689   echo $ECHO_N "(cached) $ECHO_C" >&6
7690 else
7691   if test -n "$RANLIB"; then
7692   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7693 else
7694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7695 for as_dir in $PATH
7696 do
7697   IFS=$as_save_IFS
7698   test -z "$as_dir" && as_dir=.
7699   for ac_exec_ext in '' $ac_executable_extensions; do
7700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7701     ac_cv_prog_RANLIB="${ncn_progname}"
7702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7703     break 2
7704   fi
7705 done
7706 done
7707
7708 fi
7709 fi
7710 RANLIB=$ac_cv_prog_RANLIB
7711 if test -n "$RANLIB"; then
7712   echo "$as_me:$LINENO: result: $RANLIB" >&5
7713 echo "${ECHO_T}$RANLIB" >&6
7714 else
7715   echo "$as_me:$LINENO: result: no" >&5
7716 echo "${ECHO_T}no" >&6
7717 fi
7718
7719   fi
7720   test -n "$ac_cv_prog_RANLIB" && break
7721 done
7722
7723 if test -z "$ac_cv_prog_RANLIB" ; then
7724   RANLIB=":"
7725 fi
7726
7727
7728
7729 if test -n "$STRIP"; then
7730   ac_cv_prog_STRIP=$STRIP
7731 elif test -n "$ac_cv_prog_STRIP"; then
7732   STRIP=$ac_cv_prog_STRIP
7733 fi
7734
7735 if test -n "$ac_cv_prog_STRIP"; then
7736   for ncn_progname in strip; do
7737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7738 set dummy ${ncn_progname}; ac_word=$2
7739 echo "$as_me:$LINENO: checking for $ac_word" >&5
7740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7741 if test "${ac_cv_prog_STRIP+set}" = set; then
7742   echo $ECHO_N "(cached) $ECHO_C" >&6
7743 else
7744   if test -n "$STRIP"; then
7745   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7746 else
7747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7748 for as_dir in $PATH
7749 do
7750   IFS=$as_save_IFS
7751   test -z "$as_dir" && as_dir=.
7752   for ac_exec_ext in '' $ac_executable_extensions; do
7753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7754     ac_cv_prog_STRIP="${ncn_progname}"
7755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7756     break 2
7757   fi
7758 done
7759 done
7760
7761 fi
7762 fi
7763 STRIP=$ac_cv_prog_STRIP
7764 if test -n "$STRIP"; then
7765   echo "$as_me:$LINENO: result: $STRIP" >&5
7766 echo "${ECHO_T}$STRIP" >&6
7767 else
7768   echo "$as_me:$LINENO: result: no" >&5
7769 echo "${ECHO_T}no" >&6
7770 fi
7771
7772   done
7773 fi
7774
7775 for ncn_progname in strip; do
7776   if test -n "$ncn_tool_prefix"; then
7777     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7778 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7779 echo "$as_me:$LINENO: checking for $ac_word" >&5
7780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7781 if test "${ac_cv_prog_STRIP+set}" = set; then
7782   echo $ECHO_N "(cached) $ECHO_C" >&6
7783 else
7784   if test -n "$STRIP"; then
7785   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7786 else
7787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7788 for as_dir in $PATH
7789 do
7790   IFS=$as_save_IFS
7791   test -z "$as_dir" && as_dir=.
7792   for ac_exec_ext in '' $ac_executable_extensions; do
7793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7794     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7796     break 2
7797   fi
7798 done
7799 done
7800
7801 fi
7802 fi
7803 STRIP=$ac_cv_prog_STRIP
7804 if test -n "$STRIP"; then
7805   echo "$as_me:$LINENO: result: $STRIP" >&5
7806 echo "${ECHO_T}$STRIP" >&6
7807 else
7808   echo "$as_me:$LINENO: result: no" >&5
7809 echo "${ECHO_T}no" >&6
7810 fi
7811
7812   fi
7813   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7814     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7815 set dummy ${ncn_progname}; ac_word=$2
7816 echo "$as_me:$LINENO: checking for $ac_word" >&5
7817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7818 if test "${ac_cv_prog_STRIP+set}" = set; then
7819   echo $ECHO_N "(cached) $ECHO_C" >&6
7820 else
7821   if test -n "$STRIP"; then
7822   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7823 else
7824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7825 for as_dir in $PATH
7826 do
7827   IFS=$as_save_IFS
7828   test -z "$as_dir" && as_dir=.
7829   for ac_exec_ext in '' $ac_executable_extensions; do
7830   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7831     ac_cv_prog_STRIP="${ncn_progname}"
7832     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7833     break 2
7834   fi
7835 done
7836 done
7837
7838 fi
7839 fi
7840 STRIP=$ac_cv_prog_STRIP
7841 if test -n "$STRIP"; then
7842   echo "$as_me:$LINENO: result: $STRIP" >&5
7843 echo "${ECHO_T}$STRIP" >&6
7844 else
7845   echo "$as_me:$LINENO: result: no" >&5
7846 echo "${ECHO_T}no" >&6
7847 fi
7848
7849   fi
7850   test -n "$ac_cv_prog_STRIP" && break
7851 done
7852
7853 if test -z "$ac_cv_prog_STRIP" ; then
7854   STRIP=":"
7855 fi
7856
7857
7858
7859 if test -n "$WINDRES"; then
7860   ac_cv_prog_WINDRES=$WINDRES
7861 elif test -n "$ac_cv_prog_WINDRES"; then
7862   WINDRES=$ac_cv_prog_WINDRES
7863 fi
7864
7865 if test -n "$ac_cv_prog_WINDRES"; then
7866   for ncn_progname in windres; do
7867     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7868 set dummy ${ncn_progname}; ac_word=$2
7869 echo "$as_me:$LINENO: checking for $ac_word" >&5
7870 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7871 if test "${ac_cv_prog_WINDRES+set}" = set; then
7872   echo $ECHO_N "(cached) $ECHO_C" >&6
7873 else
7874   if test -n "$WINDRES"; then
7875   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7876 else
7877 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7878 for as_dir in $PATH
7879 do
7880   IFS=$as_save_IFS
7881   test -z "$as_dir" && as_dir=.
7882   for ac_exec_ext in '' $ac_executable_extensions; do
7883   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7884     ac_cv_prog_WINDRES="${ncn_progname}"
7885     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7886     break 2
7887   fi
7888 done
7889 done
7890
7891 fi
7892 fi
7893 WINDRES=$ac_cv_prog_WINDRES
7894 if test -n "$WINDRES"; then
7895   echo "$as_me:$LINENO: result: $WINDRES" >&5
7896 echo "${ECHO_T}$WINDRES" >&6
7897 else
7898   echo "$as_me:$LINENO: result: no" >&5
7899 echo "${ECHO_T}no" >&6
7900 fi
7901
7902   done
7903 fi
7904
7905 for ncn_progname in windres; do
7906   if test -n "$ncn_tool_prefix"; then
7907     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7908 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7909 echo "$as_me:$LINENO: checking for $ac_word" >&5
7910 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7911 if test "${ac_cv_prog_WINDRES+set}" = set; then
7912   echo $ECHO_N "(cached) $ECHO_C" >&6
7913 else
7914   if test -n "$WINDRES"; then
7915   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7916 else
7917 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7918 for as_dir in $PATH
7919 do
7920   IFS=$as_save_IFS
7921   test -z "$as_dir" && as_dir=.
7922   for ac_exec_ext in '' $ac_executable_extensions; do
7923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7924     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7926     break 2
7927   fi
7928 done
7929 done
7930
7931 fi
7932 fi
7933 WINDRES=$ac_cv_prog_WINDRES
7934 if test -n "$WINDRES"; then
7935   echo "$as_me:$LINENO: result: $WINDRES" >&5
7936 echo "${ECHO_T}$WINDRES" >&6
7937 else
7938   echo "$as_me:$LINENO: result: no" >&5
7939 echo "${ECHO_T}no" >&6
7940 fi
7941
7942   fi
7943   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7944     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7945 set dummy ${ncn_progname}; ac_word=$2
7946 echo "$as_me:$LINENO: checking for $ac_word" >&5
7947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7948 if test "${ac_cv_prog_WINDRES+set}" = set; then
7949   echo $ECHO_N "(cached) $ECHO_C" >&6
7950 else
7951   if test -n "$WINDRES"; then
7952   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7953 else
7954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7955 for as_dir in $PATH
7956 do
7957   IFS=$as_save_IFS
7958   test -z "$as_dir" && as_dir=.
7959   for ac_exec_ext in '' $ac_executable_extensions; do
7960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7961     ac_cv_prog_WINDRES="${ncn_progname}"
7962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7963     break 2
7964   fi
7965 done
7966 done
7967
7968 fi
7969 fi
7970 WINDRES=$ac_cv_prog_WINDRES
7971 if test -n "$WINDRES"; then
7972   echo "$as_me:$LINENO: result: $WINDRES" >&5
7973 echo "${ECHO_T}$WINDRES" >&6
7974 else
7975   echo "$as_me:$LINENO: result: no" >&5
7976 echo "${ECHO_T}no" >&6
7977 fi
7978
7979   fi
7980   test -n "$ac_cv_prog_WINDRES" && break
7981 done
7982
7983 if test -z "$ac_cv_prog_WINDRES" ; then
7984   set dummy windres
7985   if test $build = $host ; then
7986     WINDRES="$2"
7987   else
7988     WINDRES="${ncn_tool_prefix}$2"
7989   fi
7990 fi
7991
7992
7993
7994 if test -n "$WINDMC"; then
7995   ac_cv_prog_WINDMC=$WINDMC
7996 elif test -n "$ac_cv_prog_WINDMC"; then
7997   WINDMC=$ac_cv_prog_WINDMC
7998 fi
7999
8000 if test -n "$ac_cv_prog_WINDMC"; then
8001   for ncn_progname in windmc; do
8002     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8003 set dummy ${ncn_progname}; ac_word=$2
8004 echo "$as_me:$LINENO: checking for $ac_word" >&5
8005 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8006 if test "${ac_cv_prog_WINDMC+set}" = set; then
8007   echo $ECHO_N "(cached) $ECHO_C" >&6
8008 else
8009   if test -n "$WINDMC"; then
8010   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8011 else
8012 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8013 for as_dir in $PATH
8014 do
8015   IFS=$as_save_IFS
8016   test -z "$as_dir" && as_dir=.
8017   for ac_exec_ext in '' $ac_executable_extensions; do
8018   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8019     ac_cv_prog_WINDMC="${ncn_progname}"
8020     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8021     break 2
8022   fi
8023 done
8024 done
8025
8026 fi
8027 fi
8028 WINDMC=$ac_cv_prog_WINDMC
8029 if test -n "$WINDMC"; then
8030   echo "$as_me:$LINENO: result: $WINDMC" >&5
8031 echo "${ECHO_T}$WINDMC" >&6
8032 else
8033   echo "$as_me:$LINENO: result: no" >&5
8034 echo "${ECHO_T}no" >&6
8035 fi
8036
8037   done
8038 fi
8039
8040 for ncn_progname in windmc; do
8041   if test -n "$ncn_tool_prefix"; then
8042     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8043 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8044 echo "$as_me:$LINENO: checking for $ac_word" >&5
8045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8046 if test "${ac_cv_prog_WINDMC+set}" = set; then
8047   echo $ECHO_N "(cached) $ECHO_C" >&6
8048 else
8049   if test -n "$WINDMC"; then
8050   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8051 else
8052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8053 for as_dir in $PATH
8054 do
8055   IFS=$as_save_IFS
8056   test -z "$as_dir" && as_dir=.
8057   for ac_exec_ext in '' $ac_executable_extensions; do
8058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8059     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8061     break 2
8062   fi
8063 done
8064 done
8065
8066 fi
8067 fi
8068 WINDMC=$ac_cv_prog_WINDMC
8069 if test -n "$WINDMC"; then
8070   echo "$as_me:$LINENO: result: $WINDMC" >&5
8071 echo "${ECHO_T}$WINDMC" >&6
8072 else
8073   echo "$as_me:$LINENO: result: no" >&5
8074 echo "${ECHO_T}no" >&6
8075 fi
8076
8077   fi
8078   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8079     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8080 set dummy ${ncn_progname}; ac_word=$2
8081 echo "$as_me:$LINENO: checking for $ac_word" >&5
8082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8083 if test "${ac_cv_prog_WINDMC+set}" = set; then
8084   echo $ECHO_N "(cached) $ECHO_C" >&6
8085 else
8086   if test -n "$WINDMC"; then
8087   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8088 else
8089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8090 for as_dir in $PATH
8091 do
8092   IFS=$as_save_IFS
8093   test -z "$as_dir" && as_dir=.
8094   for ac_exec_ext in '' $ac_executable_extensions; do
8095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8096     ac_cv_prog_WINDMC="${ncn_progname}"
8097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8098     break 2
8099   fi
8100 done
8101 done
8102
8103 fi
8104 fi
8105 WINDMC=$ac_cv_prog_WINDMC
8106 if test -n "$WINDMC"; then
8107   echo "$as_me:$LINENO: result: $WINDMC" >&5
8108 echo "${ECHO_T}$WINDMC" >&6
8109 else
8110   echo "$as_me:$LINENO: result: no" >&5
8111 echo "${ECHO_T}no" >&6
8112 fi
8113
8114   fi
8115   test -n "$ac_cv_prog_WINDMC" && break
8116 done
8117
8118 if test -z "$ac_cv_prog_WINDMC" ; then
8119   set dummy windmc
8120   if test $build = $host ; then
8121     WINDMC="$2"
8122   else
8123     WINDMC="${ncn_tool_prefix}$2"
8124   fi
8125 fi
8126
8127
8128
8129 if test -n "$OBJCOPY"; then
8130   ac_cv_prog_OBJCOPY=$OBJCOPY
8131 elif test -n "$ac_cv_prog_OBJCOPY"; then
8132   OBJCOPY=$ac_cv_prog_OBJCOPY
8133 fi
8134
8135 if test -n "$ac_cv_prog_OBJCOPY"; then
8136   for ncn_progname in objcopy; do
8137     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8138 set dummy ${ncn_progname}; ac_word=$2
8139 echo "$as_me:$LINENO: checking for $ac_word" >&5
8140 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8141 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8142   echo $ECHO_N "(cached) $ECHO_C" >&6
8143 else
8144   if test -n "$OBJCOPY"; then
8145   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8146 else
8147 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8148 for as_dir in $PATH
8149 do
8150   IFS=$as_save_IFS
8151   test -z "$as_dir" && as_dir=.
8152   for ac_exec_ext in '' $ac_executable_extensions; do
8153   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8154     ac_cv_prog_OBJCOPY="${ncn_progname}"
8155     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8156     break 2
8157   fi
8158 done
8159 done
8160
8161 fi
8162 fi
8163 OBJCOPY=$ac_cv_prog_OBJCOPY
8164 if test -n "$OBJCOPY"; then
8165   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8166 echo "${ECHO_T}$OBJCOPY" >&6
8167 else
8168   echo "$as_me:$LINENO: result: no" >&5
8169 echo "${ECHO_T}no" >&6
8170 fi
8171
8172   done
8173 fi
8174
8175 for ncn_progname in objcopy; do
8176   if test -n "$ncn_tool_prefix"; then
8177     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8178 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8179 echo "$as_me:$LINENO: checking for $ac_word" >&5
8180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8181 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8182   echo $ECHO_N "(cached) $ECHO_C" >&6
8183 else
8184   if test -n "$OBJCOPY"; then
8185   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8186 else
8187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8188 for as_dir in $PATH
8189 do
8190   IFS=$as_save_IFS
8191   test -z "$as_dir" && as_dir=.
8192   for ac_exec_ext in '' $ac_executable_extensions; do
8193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8194     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8196     break 2
8197   fi
8198 done
8199 done
8200
8201 fi
8202 fi
8203 OBJCOPY=$ac_cv_prog_OBJCOPY
8204 if test -n "$OBJCOPY"; then
8205   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8206 echo "${ECHO_T}$OBJCOPY" >&6
8207 else
8208   echo "$as_me:$LINENO: result: no" >&5
8209 echo "${ECHO_T}no" >&6
8210 fi
8211
8212   fi
8213   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8214     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8215 set dummy ${ncn_progname}; ac_word=$2
8216 echo "$as_me:$LINENO: checking for $ac_word" >&5
8217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8218 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8219   echo $ECHO_N "(cached) $ECHO_C" >&6
8220 else
8221   if test -n "$OBJCOPY"; then
8222   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8223 else
8224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8225 for as_dir in $PATH
8226 do
8227   IFS=$as_save_IFS
8228   test -z "$as_dir" && as_dir=.
8229   for ac_exec_ext in '' $ac_executable_extensions; do
8230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8231     ac_cv_prog_OBJCOPY="${ncn_progname}"
8232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8233     break 2
8234   fi
8235 done
8236 done
8237
8238 fi
8239 fi
8240 OBJCOPY=$ac_cv_prog_OBJCOPY
8241 if test -n "$OBJCOPY"; then
8242   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8243 echo "${ECHO_T}$OBJCOPY" >&6
8244 else
8245   echo "$as_me:$LINENO: result: no" >&5
8246 echo "${ECHO_T}no" >&6
8247 fi
8248
8249   fi
8250   test -n "$ac_cv_prog_OBJCOPY" && break
8251 done
8252
8253 if test -z "$ac_cv_prog_OBJCOPY" ; then
8254   set dummy objcopy
8255   if test $build = $host ; then
8256     OBJCOPY="$2"
8257   else
8258     OBJCOPY="${ncn_tool_prefix}$2"
8259   fi
8260 fi
8261
8262
8263
8264 if test -n "$OBJDUMP"; then
8265   ac_cv_prog_OBJDUMP=$OBJDUMP
8266 elif test -n "$ac_cv_prog_OBJDUMP"; then
8267   OBJDUMP=$ac_cv_prog_OBJDUMP
8268 fi
8269
8270 if test -n "$ac_cv_prog_OBJDUMP"; then
8271   for ncn_progname in objdump; do
8272     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8273 set dummy ${ncn_progname}; ac_word=$2
8274 echo "$as_me:$LINENO: checking for $ac_word" >&5
8275 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8276 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8277   echo $ECHO_N "(cached) $ECHO_C" >&6
8278 else
8279   if test -n "$OBJDUMP"; then
8280   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8281 else
8282 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8283 for as_dir in $PATH
8284 do
8285   IFS=$as_save_IFS
8286   test -z "$as_dir" && as_dir=.
8287   for ac_exec_ext in '' $ac_executable_extensions; do
8288   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8289     ac_cv_prog_OBJDUMP="${ncn_progname}"
8290     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8291     break 2
8292   fi
8293 done
8294 done
8295
8296 fi
8297 fi
8298 OBJDUMP=$ac_cv_prog_OBJDUMP
8299 if test -n "$OBJDUMP"; then
8300   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8301 echo "${ECHO_T}$OBJDUMP" >&6
8302 else
8303   echo "$as_me:$LINENO: result: no" >&5
8304 echo "${ECHO_T}no" >&6
8305 fi
8306
8307   done
8308 fi
8309
8310 for ncn_progname in objdump; do
8311   if test -n "$ncn_tool_prefix"; then
8312     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8313 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8314 echo "$as_me:$LINENO: checking for $ac_word" >&5
8315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8316 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8317   echo $ECHO_N "(cached) $ECHO_C" >&6
8318 else
8319   if test -n "$OBJDUMP"; then
8320   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8321 else
8322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8323 for as_dir in $PATH
8324 do
8325   IFS=$as_save_IFS
8326   test -z "$as_dir" && as_dir=.
8327   for ac_exec_ext in '' $ac_executable_extensions; do
8328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8329     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8331     break 2
8332   fi
8333 done
8334 done
8335
8336 fi
8337 fi
8338 OBJDUMP=$ac_cv_prog_OBJDUMP
8339 if test -n "$OBJDUMP"; then
8340   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8341 echo "${ECHO_T}$OBJDUMP" >&6
8342 else
8343   echo "$as_me:$LINENO: result: no" >&5
8344 echo "${ECHO_T}no" >&6
8345 fi
8346
8347   fi
8348   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8349     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8350 set dummy ${ncn_progname}; ac_word=$2
8351 echo "$as_me:$LINENO: checking for $ac_word" >&5
8352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8353 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8354   echo $ECHO_N "(cached) $ECHO_C" >&6
8355 else
8356   if test -n "$OBJDUMP"; then
8357   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8358 else
8359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8360 for as_dir in $PATH
8361 do
8362   IFS=$as_save_IFS
8363   test -z "$as_dir" && as_dir=.
8364   for ac_exec_ext in '' $ac_executable_extensions; do
8365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8366     ac_cv_prog_OBJDUMP="${ncn_progname}"
8367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8368     break 2
8369   fi
8370 done
8371 done
8372
8373 fi
8374 fi
8375 OBJDUMP=$ac_cv_prog_OBJDUMP
8376 if test -n "$OBJDUMP"; then
8377   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8378 echo "${ECHO_T}$OBJDUMP" >&6
8379 else
8380   echo "$as_me:$LINENO: result: no" >&5
8381 echo "${ECHO_T}no" >&6
8382 fi
8383
8384   fi
8385   test -n "$ac_cv_prog_OBJDUMP" && break
8386 done
8387
8388 if test -z "$ac_cv_prog_OBJDUMP" ; then
8389   set dummy objdump
8390   if test $build = $host ; then
8391     OBJDUMP="$2"
8392   else
8393     OBJDUMP="${ncn_tool_prefix}$2"
8394   fi
8395 fi
8396
8397
8398
8399
8400
8401
8402 # Target tools.
8403
8404 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8405 if test "${with_build_time_tools+set}" = set; then
8406   withval="$with_build_time_tools"
8407   case x"$withval" in
8408      x/*) ;;
8409      *)
8410        with_build_time_tools=
8411        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8412 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8413        ;;
8414    esac
8415 else
8416   with_build_time_tools=
8417 fi;
8418
8419
8420
8421 if test -n "$CC_FOR_TARGET"; then
8422   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8423 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8424   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8425 fi
8426
8427 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8428   for ncn_progname in cc gcc; do
8429     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8430 set dummy ${ncn_progname}; ac_word=$2
8431 echo "$as_me:$LINENO: checking for $ac_word" >&5
8432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8433 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8434   echo $ECHO_N "(cached) $ECHO_C" >&6
8435 else
8436   if test -n "$CC_FOR_TARGET"; then
8437   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8438 else
8439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8440 for as_dir in $PATH
8441 do
8442   IFS=$as_save_IFS
8443   test -z "$as_dir" && as_dir=.
8444   for ac_exec_ext in '' $ac_executable_extensions; do
8445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8446     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8448     break 2
8449   fi
8450 done
8451 done
8452
8453 fi
8454 fi
8455 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8456 if test -n "$CC_FOR_TARGET"; then
8457   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8458 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8459 else
8460   echo "$as_me:$LINENO: result: no" >&5
8461 echo "${ECHO_T}no" >&6
8462 fi
8463
8464   done
8465 fi
8466
8467 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8468   for ncn_progname in cc gcc; do
8469     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8470 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8471     if test -x $with_build_time_tools/${ncn_progname}; then
8472       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8473       echo "$as_me:$LINENO: result: yes" >&5
8474 echo "${ECHO_T}yes" >&6
8475       break
8476     else
8477       echo "$as_me:$LINENO: result: no" >&5
8478 echo "${ECHO_T}no" >&6
8479     fi
8480   done
8481 fi
8482
8483 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8484   for ncn_progname in cc gcc; do
8485     if test -n "$ncn_target_tool_prefix"; then
8486       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8487 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8488 echo "$as_me:$LINENO: checking for $ac_word" >&5
8489 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8490 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8491   echo $ECHO_N "(cached) $ECHO_C" >&6
8492 else
8493   if test -n "$CC_FOR_TARGET"; then
8494   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8495 else
8496 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8497 for as_dir in $PATH
8498 do
8499   IFS=$as_save_IFS
8500   test -z "$as_dir" && as_dir=.
8501   for ac_exec_ext in '' $ac_executable_extensions; do
8502   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8503     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8504     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8505     break 2
8506   fi
8507 done
8508 done
8509
8510 fi
8511 fi
8512 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8513 if test -n "$CC_FOR_TARGET"; then
8514   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8515 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8516 else
8517   echo "$as_me:$LINENO: result: no" >&5
8518 echo "${ECHO_T}no" >&6
8519 fi
8520
8521     fi
8522     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8523       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8524 set dummy ${ncn_progname}; ac_word=$2
8525 echo "$as_me:$LINENO: checking for $ac_word" >&5
8526 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8527 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8528   echo $ECHO_N "(cached) $ECHO_C" >&6
8529 else
8530   if test -n "$CC_FOR_TARGET"; then
8531   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8532 else
8533 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8534 for as_dir in $PATH
8535 do
8536   IFS=$as_save_IFS
8537   test -z "$as_dir" && as_dir=.
8538   for ac_exec_ext in '' $ac_executable_extensions; do
8539   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8540     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8541     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8542     break 2
8543   fi
8544 done
8545 done
8546
8547 fi
8548 fi
8549 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8550 if test -n "$CC_FOR_TARGET"; then
8551   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8552 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8553 else
8554   echo "$as_me:$LINENO: result: no" >&5
8555 echo "${ECHO_T}no" >&6
8556 fi
8557
8558     fi
8559     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8560   done
8561 fi
8562
8563 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8564   set dummy cc gcc
8565   if test $build = $target ; then
8566     CC_FOR_TARGET="$2"
8567   else
8568     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8569   fi
8570 else
8571   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8572 fi
8573
8574
8575
8576 if test -n "$CXX_FOR_TARGET"; then
8577   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8578 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8579   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8580 fi
8581
8582 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8583   for ncn_progname in c++ g++ cxx gxx; do
8584     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8585 set dummy ${ncn_progname}; ac_word=$2
8586 echo "$as_me:$LINENO: checking for $ac_word" >&5
8587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8588 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8589   echo $ECHO_N "(cached) $ECHO_C" >&6
8590 else
8591   if test -n "$CXX_FOR_TARGET"; then
8592   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8593 else
8594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8595 for as_dir in $PATH
8596 do
8597   IFS=$as_save_IFS
8598   test -z "$as_dir" && as_dir=.
8599   for ac_exec_ext in '' $ac_executable_extensions; do
8600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8601     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8603     break 2
8604   fi
8605 done
8606 done
8607
8608 fi
8609 fi
8610 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8611 if test -n "$CXX_FOR_TARGET"; then
8612   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8613 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8614 else
8615   echo "$as_me:$LINENO: result: no" >&5
8616 echo "${ECHO_T}no" >&6
8617 fi
8618
8619   done
8620 fi
8621
8622 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8623   for ncn_progname in c++ g++ cxx gxx; do
8624     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8625 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8626     if test -x $with_build_time_tools/${ncn_progname}; then
8627       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8628       echo "$as_me:$LINENO: result: yes" >&5
8629 echo "${ECHO_T}yes" >&6
8630       break
8631     else
8632       echo "$as_me:$LINENO: result: no" >&5
8633 echo "${ECHO_T}no" >&6
8634     fi
8635   done
8636 fi
8637
8638 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8639   for ncn_progname in c++ g++ cxx gxx; do
8640     if test -n "$ncn_target_tool_prefix"; then
8641       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8642 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8643 echo "$as_me:$LINENO: checking for $ac_word" >&5
8644 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8645 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8646   echo $ECHO_N "(cached) $ECHO_C" >&6
8647 else
8648   if test -n "$CXX_FOR_TARGET"; then
8649   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8650 else
8651 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8652 for as_dir in $PATH
8653 do
8654   IFS=$as_save_IFS
8655   test -z "$as_dir" && as_dir=.
8656   for ac_exec_ext in '' $ac_executable_extensions; do
8657   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8658     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8659     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8660     break 2
8661   fi
8662 done
8663 done
8664
8665 fi
8666 fi
8667 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8668 if test -n "$CXX_FOR_TARGET"; then
8669   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8670 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8671 else
8672   echo "$as_me:$LINENO: result: no" >&5
8673 echo "${ECHO_T}no" >&6
8674 fi
8675
8676     fi
8677     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8678       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8679 set dummy ${ncn_progname}; ac_word=$2
8680 echo "$as_me:$LINENO: checking for $ac_word" >&5
8681 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8682 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8683   echo $ECHO_N "(cached) $ECHO_C" >&6
8684 else
8685   if test -n "$CXX_FOR_TARGET"; then
8686   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8687 else
8688 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8689 for as_dir in $PATH
8690 do
8691   IFS=$as_save_IFS
8692   test -z "$as_dir" && as_dir=.
8693   for ac_exec_ext in '' $ac_executable_extensions; do
8694   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8695     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8696     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8697     break 2
8698   fi
8699 done
8700 done
8701
8702 fi
8703 fi
8704 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8705 if test -n "$CXX_FOR_TARGET"; then
8706   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8707 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8708 else
8709   echo "$as_me:$LINENO: result: no" >&5
8710 echo "${ECHO_T}no" >&6
8711 fi
8712
8713     fi
8714     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8715   done
8716 fi
8717
8718 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8719   set dummy c++ g++ cxx gxx
8720   if test $build = $target ; then
8721     CXX_FOR_TARGET="$2"
8722   else
8723     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8724   fi
8725 else
8726   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8727 fi
8728
8729
8730
8731 if test -n "$GCC_FOR_TARGET"; then
8732   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8733 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8734   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8735 fi
8736
8737 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8738   for ncn_progname in gcc; do
8739     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8740 set dummy ${ncn_progname}; ac_word=$2
8741 echo "$as_me:$LINENO: checking for $ac_word" >&5
8742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8743 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8744   echo $ECHO_N "(cached) $ECHO_C" >&6
8745 else
8746   if test -n "$GCC_FOR_TARGET"; then
8747   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8748 else
8749 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8750 for as_dir in $PATH
8751 do
8752   IFS=$as_save_IFS
8753   test -z "$as_dir" && as_dir=.
8754   for ac_exec_ext in '' $ac_executable_extensions; do
8755   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8756     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8757     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8758     break 2
8759   fi
8760 done
8761 done
8762
8763 fi
8764 fi
8765 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8766 if test -n "$GCC_FOR_TARGET"; then
8767   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8768 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8769 else
8770   echo "$as_me:$LINENO: result: no" >&5
8771 echo "${ECHO_T}no" >&6
8772 fi
8773
8774   done
8775 fi
8776
8777 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8778   for ncn_progname in gcc; do
8779     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8780 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8781     if test -x $with_build_time_tools/${ncn_progname}; then
8782       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8783       echo "$as_me:$LINENO: result: yes" >&5
8784 echo "${ECHO_T}yes" >&6
8785       break
8786     else
8787       echo "$as_me:$LINENO: result: no" >&5
8788 echo "${ECHO_T}no" >&6
8789     fi
8790   done
8791 fi
8792
8793 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8794   for ncn_progname in gcc; do
8795     if test -n "$ncn_target_tool_prefix"; then
8796       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8797 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8798 echo "$as_me:$LINENO: checking for $ac_word" >&5
8799 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8800 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8801   echo $ECHO_N "(cached) $ECHO_C" >&6
8802 else
8803   if test -n "$GCC_FOR_TARGET"; then
8804   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8805 else
8806 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8807 for as_dir in $PATH
8808 do
8809   IFS=$as_save_IFS
8810   test -z "$as_dir" && as_dir=.
8811   for ac_exec_ext in '' $ac_executable_extensions; do
8812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8813     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8815     break 2
8816   fi
8817 done
8818 done
8819
8820 fi
8821 fi
8822 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8823 if test -n "$GCC_FOR_TARGET"; then
8824   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8825 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8826 else
8827   echo "$as_me:$LINENO: result: no" >&5
8828 echo "${ECHO_T}no" >&6
8829 fi
8830
8831     fi
8832     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8833       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8834 set dummy ${ncn_progname}; ac_word=$2
8835 echo "$as_me:$LINENO: checking for $ac_word" >&5
8836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8837 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8838   echo $ECHO_N "(cached) $ECHO_C" >&6
8839 else
8840   if test -n "$GCC_FOR_TARGET"; then
8841   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8842 else
8843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8844 for as_dir in $PATH
8845 do
8846   IFS=$as_save_IFS
8847   test -z "$as_dir" && as_dir=.
8848   for ac_exec_ext in '' $ac_executable_extensions; do
8849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8850     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8852     break 2
8853   fi
8854 done
8855 done
8856
8857 fi
8858 fi
8859 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8860 if test -n "$GCC_FOR_TARGET"; then
8861   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8862 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8863 else
8864   echo "$as_me:$LINENO: result: no" >&5
8865 echo "${ECHO_T}no" >&6
8866 fi
8867
8868     fi
8869     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8870   done
8871 fi
8872
8873 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8874   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8875 else
8876   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8877 fi
8878
8879
8880
8881 if test -n "$GCJ_FOR_TARGET"; then
8882   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8883 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8884   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8885 fi
8886
8887 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8888   for ncn_progname in gcj; do
8889     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8890 set dummy ${ncn_progname}; ac_word=$2
8891 echo "$as_me:$LINENO: checking for $ac_word" >&5
8892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8893 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8894   echo $ECHO_N "(cached) $ECHO_C" >&6
8895 else
8896   if test -n "$GCJ_FOR_TARGET"; then
8897   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8898 else
8899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8900 for as_dir in $PATH
8901 do
8902   IFS=$as_save_IFS
8903   test -z "$as_dir" && as_dir=.
8904   for ac_exec_ext in '' $ac_executable_extensions; do
8905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8906     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8908     break 2
8909   fi
8910 done
8911 done
8912
8913 fi
8914 fi
8915 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8916 if test -n "$GCJ_FOR_TARGET"; then
8917   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8918 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8919 else
8920   echo "$as_me:$LINENO: result: no" >&5
8921 echo "${ECHO_T}no" >&6
8922 fi
8923
8924   done
8925 fi
8926
8927 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8928   for ncn_progname in gcj; do
8929     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8930 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8931     if test -x $with_build_time_tools/${ncn_progname}; then
8932       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8933       echo "$as_me:$LINENO: result: yes" >&5
8934 echo "${ECHO_T}yes" >&6
8935       break
8936     else
8937       echo "$as_me:$LINENO: result: no" >&5
8938 echo "${ECHO_T}no" >&6
8939     fi
8940   done
8941 fi
8942
8943 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8944   for ncn_progname in gcj; do
8945     if test -n "$ncn_target_tool_prefix"; then
8946       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8947 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8948 echo "$as_me:$LINENO: checking for $ac_word" >&5
8949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8950 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8951   echo $ECHO_N "(cached) $ECHO_C" >&6
8952 else
8953   if test -n "$GCJ_FOR_TARGET"; then
8954   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8955 else
8956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8957 for as_dir in $PATH
8958 do
8959   IFS=$as_save_IFS
8960   test -z "$as_dir" && as_dir=.
8961   for ac_exec_ext in '' $ac_executable_extensions; do
8962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8963     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8965     break 2
8966   fi
8967 done
8968 done
8969
8970 fi
8971 fi
8972 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8973 if test -n "$GCJ_FOR_TARGET"; then
8974   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8975 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8976 else
8977   echo "$as_me:$LINENO: result: no" >&5
8978 echo "${ECHO_T}no" >&6
8979 fi
8980
8981     fi
8982     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8983       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8984 set dummy ${ncn_progname}; ac_word=$2
8985 echo "$as_me:$LINENO: checking for $ac_word" >&5
8986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8987 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8988   echo $ECHO_N "(cached) $ECHO_C" >&6
8989 else
8990   if test -n "$GCJ_FOR_TARGET"; then
8991   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8992 else
8993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8994 for as_dir in $PATH
8995 do
8996   IFS=$as_save_IFS
8997   test -z "$as_dir" && as_dir=.
8998   for ac_exec_ext in '' $ac_executable_extensions; do
8999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9000     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9002     break 2
9003   fi
9004 done
9005 done
9006
9007 fi
9008 fi
9009 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9010 if test -n "$GCJ_FOR_TARGET"; then
9011   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9012 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9013 else
9014   echo "$as_me:$LINENO: result: no" >&5
9015 echo "${ECHO_T}no" >&6
9016 fi
9017
9018     fi
9019     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9020   done
9021 fi
9022
9023 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9024   set dummy gcj
9025   if test $build = $target ; then
9026     GCJ_FOR_TARGET="$2"
9027   else
9028     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9029   fi
9030 else
9031   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9032 fi
9033
9034
9035
9036 if test -n "$GFORTRAN_FOR_TARGET"; then
9037   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9038 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9039   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9040 fi
9041
9042 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9043   for ncn_progname in gfortran; do
9044     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9045 set dummy ${ncn_progname}; ac_word=$2
9046 echo "$as_me:$LINENO: checking for $ac_word" >&5
9047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9048 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9049   echo $ECHO_N "(cached) $ECHO_C" >&6
9050 else
9051   if test -n "$GFORTRAN_FOR_TARGET"; then
9052   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9053 else
9054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9055 for as_dir in $PATH
9056 do
9057   IFS=$as_save_IFS
9058   test -z "$as_dir" && as_dir=.
9059   for ac_exec_ext in '' $ac_executable_extensions; do
9060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9061     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9063     break 2
9064   fi
9065 done
9066 done
9067
9068 fi
9069 fi
9070 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9071 if test -n "$GFORTRAN_FOR_TARGET"; then
9072   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9073 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9074 else
9075   echo "$as_me:$LINENO: result: no" >&5
9076 echo "${ECHO_T}no" >&6
9077 fi
9078
9079   done
9080 fi
9081
9082 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9083   for ncn_progname in gfortran; do
9084     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9085 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9086     if test -x $with_build_time_tools/${ncn_progname}; then
9087       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9088       echo "$as_me:$LINENO: result: yes" >&5
9089 echo "${ECHO_T}yes" >&6
9090       break
9091     else
9092       echo "$as_me:$LINENO: result: no" >&5
9093 echo "${ECHO_T}no" >&6
9094     fi
9095   done
9096 fi
9097
9098 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9099   for ncn_progname in gfortran; do
9100     if test -n "$ncn_target_tool_prefix"; then
9101       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9102 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9103 echo "$as_me:$LINENO: checking for $ac_word" >&5
9104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9105 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9106   echo $ECHO_N "(cached) $ECHO_C" >&6
9107 else
9108   if test -n "$GFORTRAN_FOR_TARGET"; then
9109   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9110 else
9111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9112 for as_dir in $PATH
9113 do
9114   IFS=$as_save_IFS
9115   test -z "$as_dir" && as_dir=.
9116   for ac_exec_ext in '' $ac_executable_extensions; do
9117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9118     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9120     break 2
9121   fi
9122 done
9123 done
9124
9125 fi
9126 fi
9127 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9128 if test -n "$GFORTRAN_FOR_TARGET"; then
9129   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9130 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9131 else
9132   echo "$as_me:$LINENO: result: no" >&5
9133 echo "${ECHO_T}no" >&6
9134 fi
9135
9136     fi
9137     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9138       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9139 set dummy ${ncn_progname}; ac_word=$2
9140 echo "$as_me:$LINENO: checking for $ac_word" >&5
9141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9142 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9143   echo $ECHO_N "(cached) $ECHO_C" >&6
9144 else
9145   if test -n "$GFORTRAN_FOR_TARGET"; then
9146   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9147 else
9148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9149 for as_dir in $PATH
9150 do
9151   IFS=$as_save_IFS
9152   test -z "$as_dir" && as_dir=.
9153   for ac_exec_ext in '' $ac_executable_extensions; do
9154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9155     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9157     break 2
9158   fi
9159 done
9160 done
9161
9162 fi
9163 fi
9164 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9165 if test -n "$GFORTRAN_FOR_TARGET"; then
9166   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9167 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9168 else
9169   echo "$as_me:$LINENO: result: no" >&5
9170 echo "${ECHO_T}no" >&6
9171 fi
9172
9173     fi
9174     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9175   done
9176 fi
9177
9178 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9179   set dummy gfortran
9180   if test $build = $target ; then
9181     GFORTRAN_FOR_TARGET="$2"
9182   else
9183     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9184   fi
9185 else
9186   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9187 fi
9188
9189
9190
9191 cat > conftest.c << \EOF
9192 #ifdef __GNUC__
9193   gcc_yay;
9194 #endif
9195 EOF
9196 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9197   have_gcc_for_target=yes
9198 else
9199   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9200   have_gcc_for_target=no
9201 fi
9202 rm conftest.c
9203
9204
9205
9206
9207 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9208   if test -n "$with_build_time_tools"; then
9209     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9210 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9211     if test -x $with_build_time_tools/ar; then
9212       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9213       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9214       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9215 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9216     else
9217       echo "$as_me:$LINENO: result: no" >&5
9218 echo "${ECHO_T}no" >&6
9219     fi
9220   elif test $build != $host && test $have_gcc_for_target = yes; then
9221     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9222     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9223     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9224   fi
9225 fi
9226 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9227   # Extract the first word of "ar", so it can be a program name with args.
9228 set dummy ar; ac_word=$2
9229 echo "$as_me:$LINENO: checking for $ac_word" >&5
9230 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9231 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9232   echo $ECHO_N "(cached) $ECHO_C" >&6
9233 else
9234   case $AR_FOR_TARGET in
9235   [\\/]* | ?:[\\/]*)
9236   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9237   ;;
9238   *)
9239   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9240 for as_dir in $gcc_cv_tool_dirs
9241 do
9242   IFS=$as_save_IFS
9243   test -z "$as_dir" && as_dir=.
9244   for ac_exec_ext in '' $ac_executable_extensions; do
9245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9246     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9248     break 2
9249   fi
9250 done
9251 done
9252
9253   ;;
9254 esac
9255 fi
9256 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9257
9258 if test -n "$AR_FOR_TARGET"; then
9259   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9260 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9261 else
9262   echo "$as_me:$LINENO: result: no" >&5
9263 echo "${ECHO_T}no" >&6
9264 fi
9265
9266 fi
9267 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9268
9269
9270 if test -n "$AR_FOR_TARGET"; then
9271   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9272 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9273   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9274 fi
9275
9276 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9277   for ncn_progname in ar; do
9278     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9279 set dummy ${ncn_progname}; ac_word=$2
9280 echo "$as_me:$LINENO: checking for $ac_word" >&5
9281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9282 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9283   echo $ECHO_N "(cached) $ECHO_C" >&6
9284 else
9285   if test -n "$AR_FOR_TARGET"; then
9286   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9287 else
9288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9289 for as_dir in $PATH
9290 do
9291   IFS=$as_save_IFS
9292   test -z "$as_dir" && as_dir=.
9293   for ac_exec_ext in '' $ac_executable_extensions; do
9294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9295     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9297     break 2
9298   fi
9299 done
9300 done
9301
9302 fi
9303 fi
9304 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9305 if test -n "$AR_FOR_TARGET"; then
9306   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9307 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9308 else
9309   echo "$as_me:$LINENO: result: no" >&5
9310 echo "${ECHO_T}no" >&6
9311 fi
9312
9313   done
9314 fi
9315
9316 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9317   for ncn_progname in ar; do
9318     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9319 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9320     if test -x $with_build_time_tools/${ncn_progname}; then
9321       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9322       echo "$as_me:$LINENO: result: yes" >&5
9323 echo "${ECHO_T}yes" >&6
9324       break
9325     else
9326       echo "$as_me:$LINENO: result: no" >&5
9327 echo "${ECHO_T}no" >&6
9328     fi
9329   done
9330 fi
9331
9332 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9333   for ncn_progname in ar; do
9334     if test -n "$ncn_target_tool_prefix"; then
9335       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9336 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9337 echo "$as_me:$LINENO: checking for $ac_word" >&5
9338 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9339 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9340   echo $ECHO_N "(cached) $ECHO_C" >&6
9341 else
9342   if test -n "$AR_FOR_TARGET"; then
9343   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9344 else
9345 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9346 for as_dir in $PATH
9347 do
9348   IFS=$as_save_IFS
9349   test -z "$as_dir" && as_dir=.
9350   for ac_exec_ext in '' $ac_executable_extensions; do
9351   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9352     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9353     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9354     break 2
9355   fi
9356 done
9357 done
9358
9359 fi
9360 fi
9361 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9362 if test -n "$AR_FOR_TARGET"; then
9363   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9364 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9365 else
9366   echo "$as_me:$LINENO: result: no" >&5
9367 echo "${ECHO_T}no" >&6
9368 fi
9369
9370     fi
9371     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9372       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9373 set dummy ${ncn_progname}; ac_word=$2
9374 echo "$as_me:$LINENO: checking for $ac_word" >&5
9375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9376 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9377   echo $ECHO_N "(cached) $ECHO_C" >&6
9378 else
9379   if test -n "$AR_FOR_TARGET"; then
9380   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9381 else
9382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9383 for as_dir in $PATH
9384 do
9385   IFS=$as_save_IFS
9386   test -z "$as_dir" && as_dir=.
9387   for ac_exec_ext in '' $ac_executable_extensions; do
9388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9389     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9391     break 2
9392   fi
9393 done
9394 done
9395
9396 fi
9397 fi
9398 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9399 if test -n "$AR_FOR_TARGET"; then
9400   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9401 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9402 else
9403   echo "$as_me:$LINENO: result: no" >&5
9404 echo "${ECHO_T}no" >&6
9405 fi
9406
9407     fi
9408     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9409   done
9410 fi
9411
9412 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9413   set dummy ar
9414   if test $build = $target ; then
9415     AR_FOR_TARGET="$2"
9416   else
9417     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9418   fi
9419 else
9420   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9421 fi
9422
9423 else
9424   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9425 fi
9426
9427
9428
9429
9430 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9431   if test -n "$with_build_time_tools"; then
9432     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9433 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9434     if test -x $with_build_time_tools/as; then
9435       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9436       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9437       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9438 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9439     else
9440       echo "$as_me:$LINENO: result: no" >&5
9441 echo "${ECHO_T}no" >&6
9442     fi
9443   elif test $build != $host && test $have_gcc_for_target = yes; then
9444     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9445     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9446     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9447   fi
9448 fi
9449 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9450   # Extract the first word of "as", so it can be a program name with args.
9451 set dummy as; ac_word=$2
9452 echo "$as_me:$LINENO: checking for $ac_word" >&5
9453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9454 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9455   echo $ECHO_N "(cached) $ECHO_C" >&6
9456 else
9457   case $AS_FOR_TARGET in
9458   [\\/]* | ?:[\\/]*)
9459   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9460   ;;
9461   *)
9462   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9463 for as_dir in $gcc_cv_tool_dirs
9464 do
9465   IFS=$as_save_IFS
9466   test -z "$as_dir" && as_dir=.
9467   for ac_exec_ext in '' $ac_executable_extensions; do
9468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9469     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9471     break 2
9472   fi
9473 done
9474 done
9475
9476   ;;
9477 esac
9478 fi
9479 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9480
9481 if test -n "$AS_FOR_TARGET"; then
9482   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9483 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9484 else
9485   echo "$as_me:$LINENO: result: no" >&5
9486 echo "${ECHO_T}no" >&6
9487 fi
9488
9489 fi
9490 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9491
9492
9493 if test -n "$AS_FOR_TARGET"; then
9494   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9495 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9496   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9497 fi
9498
9499 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9500   for ncn_progname in as; do
9501     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9502 set dummy ${ncn_progname}; ac_word=$2
9503 echo "$as_me:$LINENO: checking for $ac_word" >&5
9504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9505 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9506   echo $ECHO_N "(cached) $ECHO_C" >&6
9507 else
9508   if test -n "$AS_FOR_TARGET"; then
9509   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9510 else
9511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9512 for as_dir in $PATH
9513 do
9514   IFS=$as_save_IFS
9515   test -z "$as_dir" && as_dir=.
9516   for ac_exec_ext in '' $ac_executable_extensions; do
9517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9518     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9520     break 2
9521   fi
9522 done
9523 done
9524
9525 fi
9526 fi
9527 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9528 if test -n "$AS_FOR_TARGET"; then
9529   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9530 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9531 else
9532   echo "$as_me:$LINENO: result: no" >&5
9533 echo "${ECHO_T}no" >&6
9534 fi
9535
9536   done
9537 fi
9538
9539 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9540   for ncn_progname in as; do
9541     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9542 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9543     if test -x $with_build_time_tools/${ncn_progname}; then
9544       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9545       echo "$as_me:$LINENO: result: yes" >&5
9546 echo "${ECHO_T}yes" >&6
9547       break
9548     else
9549       echo "$as_me:$LINENO: result: no" >&5
9550 echo "${ECHO_T}no" >&6
9551     fi
9552   done
9553 fi
9554
9555 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9556   for ncn_progname in as; do
9557     if test -n "$ncn_target_tool_prefix"; then
9558       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9559 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9560 echo "$as_me:$LINENO: checking for $ac_word" >&5
9561 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9562 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9563   echo $ECHO_N "(cached) $ECHO_C" >&6
9564 else
9565   if test -n "$AS_FOR_TARGET"; then
9566   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9567 else
9568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9569 for as_dir in $PATH
9570 do
9571   IFS=$as_save_IFS
9572   test -z "$as_dir" && as_dir=.
9573   for ac_exec_ext in '' $ac_executable_extensions; do
9574   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9575     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9576     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9577     break 2
9578   fi
9579 done
9580 done
9581
9582 fi
9583 fi
9584 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9585 if test -n "$AS_FOR_TARGET"; then
9586   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9587 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9588 else
9589   echo "$as_me:$LINENO: result: no" >&5
9590 echo "${ECHO_T}no" >&6
9591 fi
9592
9593     fi
9594     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9595       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9596 set dummy ${ncn_progname}; ac_word=$2
9597 echo "$as_me:$LINENO: checking for $ac_word" >&5
9598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9599 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9600   echo $ECHO_N "(cached) $ECHO_C" >&6
9601 else
9602   if test -n "$AS_FOR_TARGET"; then
9603   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9604 else
9605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9606 for as_dir in $PATH
9607 do
9608   IFS=$as_save_IFS
9609   test -z "$as_dir" && as_dir=.
9610   for ac_exec_ext in '' $ac_executable_extensions; do
9611   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9612     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9613     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9614     break 2
9615   fi
9616 done
9617 done
9618
9619 fi
9620 fi
9621 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9622 if test -n "$AS_FOR_TARGET"; then
9623   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9624 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9625 else
9626   echo "$as_me:$LINENO: result: no" >&5
9627 echo "${ECHO_T}no" >&6
9628 fi
9629
9630     fi
9631     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9632   done
9633 fi
9634
9635 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9636   set dummy as
9637   if test $build = $target ; then
9638     AS_FOR_TARGET="$2"
9639   else
9640     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9641   fi
9642 else
9643   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9644 fi
9645
9646 else
9647   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9648 fi
9649
9650
9651
9652
9653 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9654   if test -n "$with_build_time_tools"; then
9655     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9656 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9657     if test -x $with_build_time_tools/dlltool; then
9658       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9659       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9660       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9661 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9662     else
9663       echo "$as_me:$LINENO: result: no" >&5
9664 echo "${ECHO_T}no" >&6
9665     fi
9666   elif test $build != $host && test $have_gcc_for_target = yes; then
9667     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9668     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9669     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9670   fi
9671 fi
9672 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9673   # Extract the first word of "dlltool", so it can be a program name with args.
9674 set dummy dlltool; ac_word=$2
9675 echo "$as_me:$LINENO: checking for $ac_word" >&5
9676 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9677 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9678   echo $ECHO_N "(cached) $ECHO_C" >&6
9679 else
9680   case $DLLTOOL_FOR_TARGET in
9681   [\\/]* | ?:[\\/]*)
9682   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9683   ;;
9684   *)
9685   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9686 for as_dir in $gcc_cv_tool_dirs
9687 do
9688   IFS=$as_save_IFS
9689   test -z "$as_dir" && as_dir=.
9690   for ac_exec_ext in '' $ac_executable_extensions; do
9691   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9692     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9693     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9694     break 2
9695   fi
9696 done
9697 done
9698
9699   ;;
9700 esac
9701 fi
9702 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9703
9704 if test -n "$DLLTOOL_FOR_TARGET"; then
9705   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9706 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9707 else
9708   echo "$as_me:$LINENO: result: no" >&5
9709 echo "${ECHO_T}no" >&6
9710 fi
9711
9712 fi
9713 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9714
9715
9716 if test -n "$DLLTOOL_FOR_TARGET"; then
9717   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9718 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9719   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9720 fi
9721
9722 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9723   for ncn_progname in dlltool; do
9724     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9725 set dummy ${ncn_progname}; ac_word=$2
9726 echo "$as_me:$LINENO: checking for $ac_word" >&5
9727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9728 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9729   echo $ECHO_N "(cached) $ECHO_C" >&6
9730 else
9731   if test -n "$DLLTOOL_FOR_TARGET"; then
9732   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9733 else
9734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9735 for as_dir in $PATH
9736 do
9737   IFS=$as_save_IFS
9738   test -z "$as_dir" && as_dir=.
9739   for ac_exec_ext in '' $ac_executable_extensions; do
9740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9741     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9743     break 2
9744   fi
9745 done
9746 done
9747
9748 fi
9749 fi
9750 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9751 if test -n "$DLLTOOL_FOR_TARGET"; then
9752   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9753 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9754 else
9755   echo "$as_me:$LINENO: result: no" >&5
9756 echo "${ECHO_T}no" >&6
9757 fi
9758
9759   done
9760 fi
9761
9762 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9763   for ncn_progname in dlltool; do
9764     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9765 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9766     if test -x $with_build_time_tools/${ncn_progname}; then
9767       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9768       echo "$as_me:$LINENO: result: yes" >&5
9769 echo "${ECHO_T}yes" >&6
9770       break
9771     else
9772       echo "$as_me:$LINENO: result: no" >&5
9773 echo "${ECHO_T}no" >&6
9774     fi
9775   done
9776 fi
9777
9778 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9779   for ncn_progname in dlltool; do
9780     if test -n "$ncn_target_tool_prefix"; then
9781       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9782 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9783 echo "$as_me:$LINENO: checking for $ac_word" >&5
9784 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9785 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9786   echo $ECHO_N "(cached) $ECHO_C" >&6
9787 else
9788   if test -n "$DLLTOOL_FOR_TARGET"; then
9789   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9790 else
9791 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9792 for as_dir in $PATH
9793 do
9794   IFS=$as_save_IFS
9795   test -z "$as_dir" && as_dir=.
9796   for ac_exec_ext in '' $ac_executable_extensions; do
9797   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9798     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9799     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9800     break 2
9801   fi
9802 done
9803 done
9804
9805 fi
9806 fi
9807 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9808 if test -n "$DLLTOOL_FOR_TARGET"; then
9809   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9810 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9811 else
9812   echo "$as_me:$LINENO: result: no" >&5
9813 echo "${ECHO_T}no" >&6
9814 fi
9815
9816     fi
9817     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9818       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9819 set dummy ${ncn_progname}; ac_word=$2
9820 echo "$as_me:$LINENO: checking for $ac_word" >&5
9821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9822 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9823   echo $ECHO_N "(cached) $ECHO_C" >&6
9824 else
9825   if test -n "$DLLTOOL_FOR_TARGET"; then
9826   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9827 else
9828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9829 for as_dir in $PATH
9830 do
9831   IFS=$as_save_IFS
9832   test -z "$as_dir" && as_dir=.
9833   for ac_exec_ext in '' $ac_executable_extensions; do
9834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9835     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9837     break 2
9838   fi
9839 done
9840 done
9841
9842 fi
9843 fi
9844 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9845 if test -n "$DLLTOOL_FOR_TARGET"; then
9846   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9847 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9848 else
9849   echo "$as_me:$LINENO: result: no" >&5
9850 echo "${ECHO_T}no" >&6
9851 fi
9852
9853     fi
9854     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9855   done
9856 fi
9857
9858 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9859   set dummy dlltool
9860   if test $build = $target ; then
9861     DLLTOOL_FOR_TARGET="$2"
9862   else
9863     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9864   fi
9865 else
9866   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9867 fi
9868
9869 else
9870   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9871 fi
9872
9873
9874
9875
9876 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9877   if test -n "$with_build_time_tools"; then
9878     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9879 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9880     if test -x $with_build_time_tools/ld; then
9881       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9882       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9883       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9884 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9885     else
9886       echo "$as_me:$LINENO: result: no" >&5
9887 echo "${ECHO_T}no" >&6
9888     fi
9889   elif test $build != $host && test $have_gcc_for_target = yes; then
9890     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9891     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9892     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9893   fi
9894 fi
9895 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9896   # Extract the first word of "ld", so it can be a program name with args.
9897 set dummy ld; ac_word=$2
9898 echo "$as_me:$LINENO: checking for $ac_word" >&5
9899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9900 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9901   echo $ECHO_N "(cached) $ECHO_C" >&6
9902 else
9903   case $LD_FOR_TARGET in
9904   [\\/]* | ?:[\\/]*)
9905   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9906   ;;
9907   *)
9908   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9909 for as_dir in $gcc_cv_tool_dirs
9910 do
9911   IFS=$as_save_IFS
9912   test -z "$as_dir" && as_dir=.
9913   for ac_exec_ext in '' $ac_executable_extensions; do
9914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9915     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9917     break 2
9918   fi
9919 done
9920 done
9921
9922   ;;
9923 esac
9924 fi
9925 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9926
9927 if test -n "$LD_FOR_TARGET"; then
9928   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9929 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9930 else
9931   echo "$as_me:$LINENO: result: no" >&5
9932 echo "${ECHO_T}no" >&6
9933 fi
9934
9935 fi
9936 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9937
9938
9939 if test -n "$LD_FOR_TARGET"; then
9940   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9941 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9942   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9943 fi
9944
9945 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9946   for ncn_progname in ld; do
9947     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9948 set dummy ${ncn_progname}; ac_word=$2
9949 echo "$as_me:$LINENO: checking for $ac_word" >&5
9950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9951 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9952   echo $ECHO_N "(cached) $ECHO_C" >&6
9953 else
9954   if test -n "$LD_FOR_TARGET"; then
9955   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9956 else
9957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9958 for as_dir in $PATH
9959 do
9960   IFS=$as_save_IFS
9961   test -z "$as_dir" && as_dir=.
9962   for ac_exec_ext in '' $ac_executable_extensions; do
9963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9964     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9966     break 2
9967   fi
9968 done
9969 done
9970
9971 fi
9972 fi
9973 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9974 if test -n "$LD_FOR_TARGET"; then
9975   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9976 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9977 else
9978   echo "$as_me:$LINENO: result: no" >&5
9979 echo "${ECHO_T}no" >&6
9980 fi
9981
9982   done
9983 fi
9984
9985 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9986   for ncn_progname in ld; do
9987     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9988 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9989     if test -x $with_build_time_tools/${ncn_progname}; then
9990       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9991       echo "$as_me:$LINENO: result: yes" >&5
9992 echo "${ECHO_T}yes" >&6
9993       break
9994     else
9995       echo "$as_me:$LINENO: result: no" >&5
9996 echo "${ECHO_T}no" >&6
9997     fi
9998   done
9999 fi
10000
10001 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10002   for ncn_progname in ld; do
10003     if test -n "$ncn_target_tool_prefix"; then
10004       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10005 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10006 echo "$as_me:$LINENO: checking for $ac_word" >&5
10007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10008 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10009   echo $ECHO_N "(cached) $ECHO_C" >&6
10010 else
10011   if test -n "$LD_FOR_TARGET"; then
10012   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10013 else
10014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10015 for as_dir in $PATH
10016 do
10017   IFS=$as_save_IFS
10018   test -z "$as_dir" && as_dir=.
10019   for ac_exec_ext in '' $ac_executable_extensions; do
10020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10021     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10023     break 2
10024   fi
10025 done
10026 done
10027
10028 fi
10029 fi
10030 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10031 if test -n "$LD_FOR_TARGET"; then
10032   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10033 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10034 else
10035   echo "$as_me:$LINENO: result: no" >&5
10036 echo "${ECHO_T}no" >&6
10037 fi
10038
10039     fi
10040     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10041       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10042 set dummy ${ncn_progname}; ac_word=$2
10043 echo "$as_me:$LINENO: checking for $ac_word" >&5
10044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10045 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10046   echo $ECHO_N "(cached) $ECHO_C" >&6
10047 else
10048   if test -n "$LD_FOR_TARGET"; then
10049   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10050 else
10051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10052 for as_dir in $PATH
10053 do
10054   IFS=$as_save_IFS
10055   test -z "$as_dir" && as_dir=.
10056   for ac_exec_ext in '' $ac_executable_extensions; do
10057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10058     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10060     break 2
10061   fi
10062 done
10063 done
10064
10065 fi
10066 fi
10067 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10068 if test -n "$LD_FOR_TARGET"; then
10069   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10070 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10071 else
10072   echo "$as_me:$LINENO: result: no" >&5
10073 echo "${ECHO_T}no" >&6
10074 fi
10075
10076     fi
10077     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10078   done
10079 fi
10080
10081 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10082   set dummy ld
10083   if test $build = $target ; then
10084     LD_FOR_TARGET="$2"
10085   else
10086     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10087   fi
10088 else
10089   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10090 fi
10091
10092 else
10093   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10094 fi
10095
10096
10097
10098
10099 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10100   if test -n "$with_build_time_tools"; then
10101     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10102 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10103     if test -x $with_build_time_tools/lipo; then
10104       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10105       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10106       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10107 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10108     else
10109       echo "$as_me:$LINENO: result: no" >&5
10110 echo "${ECHO_T}no" >&6
10111     fi
10112   elif test $build != $host && test $have_gcc_for_target = yes; then
10113     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10114     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10115     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10116   fi
10117 fi
10118 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10119   # Extract the first word of "lipo", so it can be a program name with args.
10120 set dummy lipo; ac_word=$2
10121 echo "$as_me:$LINENO: checking for $ac_word" >&5
10122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10123 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10124   echo $ECHO_N "(cached) $ECHO_C" >&6
10125 else
10126   case $LIPO_FOR_TARGET in
10127   [\\/]* | ?:[\\/]*)
10128   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10129   ;;
10130   *)
10131   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 for as_dir in $gcc_cv_tool_dirs
10133 do
10134   IFS=$as_save_IFS
10135   test -z "$as_dir" && as_dir=.
10136   for ac_exec_ext in '' $ac_executable_extensions; do
10137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10140     break 2
10141   fi
10142 done
10143 done
10144
10145   ;;
10146 esac
10147 fi
10148 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10149
10150 if test -n "$LIPO_FOR_TARGET"; then
10151   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10152 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10153 else
10154   echo "$as_me:$LINENO: result: no" >&5
10155 echo "${ECHO_T}no" >&6
10156 fi
10157
10158 fi
10159 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10160
10161
10162 if test -n "$LIPO_FOR_TARGET"; then
10163   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10164 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10165   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10166 fi
10167
10168 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10169   for ncn_progname in lipo; do
10170     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10171 set dummy ${ncn_progname}; ac_word=$2
10172 echo "$as_me:$LINENO: checking for $ac_word" >&5
10173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10174 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10175   echo $ECHO_N "(cached) $ECHO_C" >&6
10176 else
10177   if test -n "$LIPO_FOR_TARGET"; then
10178   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10179 else
10180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10181 for as_dir in $PATH
10182 do
10183   IFS=$as_save_IFS
10184   test -z "$as_dir" && as_dir=.
10185   for ac_exec_ext in '' $ac_executable_extensions; do
10186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10187     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10189     break 2
10190   fi
10191 done
10192 done
10193
10194 fi
10195 fi
10196 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10197 if test -n "$LIPO_FOR_TARGET"; then
10198   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10199 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10200 else
10201   echo "$as_me:$LINENO: result: no" >&5
10202 echo "${ECHO_T}no" >&6
10203 fi
10204
10205   done
10206 fi
10207
10208 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10209   for ncn_progname in lipo; do
10210     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10211 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10212     if test -x $with_build_time_tools/${ncn_progname}; then
10213       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10214       echo "$as_me:$LINENO: result: yes" >&5
10215 echo "${ECHO_T}yes" >&6
10216       break
10217     else
10218       echo "$as_me:$LINENO: result: no" >&5
10219 echo "${ECHO_T}no" >&6
10220     fi
10221   done
10222 fi
10223
10224 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10225   for ncn_progname in lipo; do
10226     if test -n "$ncn_target_tool_prefix"; then
10227       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10228 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10229 echo "$as_me:$LINENO: checking for $ac_word" >&5
10230 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10231 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10232   echo $ECHO_N "(cached) $ECHO_C" >&6
10233 else
10234   if test -n "$LIPO_FOR_TARGET"; then
10235   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10236 else
10237 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10238 for as_dir in $PATH
10239 do
10240   IFS=$as_save_IFS
10241   test -z "$as_dir" && as_dir=.
10242   for ac_exec_ext in '' $ac_executable_extensions; do
10243   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10244     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10245     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10246     break 2
10247   fi
10248 done
10249 done
10250
10251 fi
10252 fi
10253 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10254 if test -n "$LIPO_FOR_TARGET"; then
10255   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10256 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10257 else
10258   echo "$as_me:$LINENO: result: no" >&5
10259 echo "${ECHO_T}no" >&6
10260 fi
10261
10262     fi
10263     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10264       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10265 set dummy ${ncn_progname}; ac_word=$2
10266 echo "$as_me:$LINENO: checking for $ac_word" >&5
10267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10268 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10269   echo $ECHO_N "(cached) $ECHO_C" >&6
10270 else
10271   if test -n "$LIPO_FOR_TARGET"; then
10272   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10273 else
10274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10275 for as_dir in $PATH
10276 do
10277   IFS=$as_save_IFS
10278   test -z "$as_dir" && as_dir=.
10279   for ac_exec_ext in '' $ac_executable_extensions; do
10280   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10281     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10282     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10283     break 2
10284   fi
10285 done
10286 done
10287
10288 fi
10289 fi
10290 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10291 if test -n "$LIPO_FOR_TARGET"; then
10292   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10293 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10294 else
10295   echo "$as_me:$LINENO: result: no" >&5
10296 echo "${ECHO_T}no" >&6
10297 fi
10298
10299     fi
10300     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10301   done
10302 fi
10303
10304 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10305   set dummy lipo
10306   if test $build = $target ; then
10307     LIPO_FOR_TARGET="$2"
10308   else
10309     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10310   fi
10311 else
10312   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10313 fi
10314
10315 else
10316   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10317 fi
10318
10319
10320
10321
10322 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10323   if test -n "$with_build_time_tools"; then
10324     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10325 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10326     if test -x $with_build_time_tools/nm; then
10327       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10328       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10329       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10330 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10331     else
10332       echo "$as_me:$LINENO: result: no" >&5
10333 echo "${ECHO_T}no" >&6
10334     fi
10335   elif test $build != $host && test $have_gcc_for_target = yes; then
10336     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10337     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10338     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10339   fi
10340 fi
10341 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10342   # Extract the first word of "nm", so it can be a program name with args.
10343 set dummy nm; ac_word=$2
10344 echo "$as_me:$LINENO: checking for $ac_word" >&5
10345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10346 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10347   echo $ECHO_N "(cached) $ECHO_C" >&6
10348 else
10349   case $NM_FOR_TARGET in
10350   [\\/]* | ?:[\\/]*)
10351   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10352   ;;
10353   *)
10354   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10355 for as_dir in $gcc_cv_tool_dirs
10356 do
10357   IFS=$as_save_IFS
10358   test -z "$as_dir" && as_dir=.
10359   for ac_exec_ext in '' $ac_executable_extensions; do
10360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10361     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10363     break 2
10364   fi
10365 done
10366 done
10367
10368   ;;
10369 esac
10370 fi
10371 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10372
10373 if test -n "$NM_FOR_TARGET"; then
10374   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10375 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10376 else
10377   echo "$as_me:$LINENO: result: no" >&5
10378 echo "${ECHO_T}no" >&6
10379 fi
10380
10381 fi
10382 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10383
10384
10385 if test -n "$NM_FOR_TARGET"; then
10386   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10387 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10388   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10389 fi
10390
10391 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10392   for ncn_progname in nm; do
10393     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10394 set dummy ${ncn_progname}; ac_word=$2
10395 echo "$as_me:$LINENO: checking for $ac_word" >&5
10396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10397 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10398   echo $ECHO_N "(cached) $ECHO_C" >&6
10399 else
10400   if test -n "$NM_FOR_TARGET"; then
10401   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10402 else
10403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 for as_dir in $PATH
10405 do
10406   IFS=$as_save_IFS
10407   test -z "$as_dir" && as_dir=.
10408   for ac_exec_ext in '' $ac_executable_extensions; do
10409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10412     break 2
10413   fi
10414 done
10415 done
10416
10417 fi
10418 fi
10419 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10420 if test -n "$NM_FOR_TARGET"; then
10421   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10422 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10423 else
10424   echo "$as_me:$LINENO: result: no" >&5
10425 echo "${ECHO_T}no" >&6
10426 fi
10427
10428   done
10429 fi
10430
10431 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10432   for ncn_progname in nm; do
10433     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10434 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10435     if test -x $with_build_time_tools/${ncn_progname}; then
10436       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10437       echo "$as_me:$LINENO: result: yes" >&5
10438 echo "${ECHO_T}yes" >&6
10439       break
10440     else
10441       echo "$as_me:$LINENO: result: no" >&5
10442 echo "${ECHO_T}no" >&6
10443     fi
10444   done
10445 fi
10446
10447 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10448   for ncn_progname in nm; do
10449     if test -n "$ncn_target_tool_prefix"; then
10450       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10451 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10452 echo "$as_me:$LINENO: checking for $ac_word" >&5
10453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10454 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10455   echo $ECHO_N "(cached) $ECHO_C" >&6
10456 else
10457   if test -n "$NM_FOR_TARGET"; then
10458   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10459 else
10460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10461 for as_dir in $PATH
10462 do
10463   IFS=$as_save_IFS
10464   test -z "$as_dir" && as_dir=.
10465   for ac_exec_ext in '' $ac_executable_extensions; do
10466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10467     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10469     break 2
10470   fi
10471 done
10472 done
10473
10474 fi
10475 fi
10476 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10477 if test -n "$NM_FOR_TARGET"; then
10478   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10479 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10480 else
10481   echo "$as_me:$LINENO: result: no" >&5
10482 echo "${ECHO_T}no" >&6
10483 fi
10484
10485     fi
10486     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10487       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10488 set dummy ${ncn_progname}; ac_word=$2
10489 echo "$as_me:$LINENO: checking for $ac_word" >&5
10490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10491 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10492   echo $ECHO_N "(cached) $ECHO_C" >&6
10493 else
10494   if test -n "$NM_FOR_TARGET"; then
10495   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10496 else
10497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10498 for as_dir in $PATH
10499 do
10500   IFS=$as_save_IFS
10501   test -z "$as_dir" && as_dir=.
10502   for ac_exec_ext in '' $ac_executable_extensions; do
10503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10504     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10506     break 2
10507   fi
10508 done
10509 done
10510
10511 fi
10512 fi
10513 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10514 if test -n "$NM_FOR_TARGET"; then
10515   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10516 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10517 else
10518   echo "$as_me:$LINENO: result: no" >&5
10519 echo "${ECHO_T}no" >&6
10520 fi
10521
10522     fi
10523     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10524   done
10525 fi
10526
10527 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10528   set dummy nm
10529   if test $build = $target ; then
10530     NM_FOR_TARGET="$2"
10531   else
10532     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10533   fi
10534 else
10535   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10536 fi
10537
10538 else
10539   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10540 fi
10541
10542
10543
10544
10545 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10546   if test -n "$with_build_time_tools"; then
10547     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10548 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10549     if test -x $with_build_time_tools/objdump; then
10550       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10551       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10552       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10553 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10554     else
10555       echo "$as_me:$LINENO: result: no" >&5
10556 echo "${ECHO_T}no" >&6
10557     fi
10558   elif test $build != $host && test $have_gcc_for_target = yes; then
10559     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10560     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10561     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10562   fi
10563 fi
10564 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10565   # Extract the first word of "objdump", so it can be a program name with args.
10566 set dummy objdump; ac_word=$2
10567 echo "$as_me:$LINENO: checking for $ac_word" >&5
10568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10569 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10570   echo $ECHO_N "(cached) $ECHO_C" >&6
10571 else
10572   case $OBJDUMP_FOR_TARGET in
10573   [\\/]* | ?:[\\/]*)
10574   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10575   ;;
10576   *)
10577   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10578 for as_dir in $gcc_cv_tool_dirs
10579 do
10580   IFS=$as_save_IFS
10581   test -z "$as_dir" && as_dir=.
10582   for ac_exec_ext in '' $ac_executable_extensions; do
10583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10584     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10586     break 2
10587   fi
10588 done
10589 done
10590
10591   ;;
10592 esac
10593 fi
10594 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10595
10596 if test -n "$OBJDUMP_FOR_TARGET"; then
10597   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10598 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10599 else
10600   echo "$as_me:$LINENO: result: no" >&5
10601 echo "${ECHO_T}no" >&6
10602 fi
10603
10604 fi
10605 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10606
10607
10608 if test -n "$OBJDUMP_FOR_TARGET"; then
10609   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10610 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10611   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10612 fi
10613
10614 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10615   for ncn_progname in objdump; do
10616     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10617 set dummy ${ncn_progname}; ac_word=$2
10618 echo "$as_me:$LINENO: checking for $ac_word" >&5
10619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10620 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10621   echo $ECHO_N "(cached) $ECHO_C" >&6
10622 else
10623   if test -n "$OBJDUMP_FOR_TARGET"; then
10624   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10625 else
10626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10627 for as_dir in $PATH
10628 do
10629   IFS=$as_save_IFS
10630   test -z "$as_dir" && as_dir=.
10631   for ac_exec_ext in '' $ac_executable_extensions; do
10632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10633     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10635     break 2
10636   fi
10637 done
10638 done
10639
10640 fi
10641 fi
10642 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10643 if test -n "$OBJDUMP_FOR_TARGET"; then
10644   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10645 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10646 else
10647   echo "$as_me:$LINENO: result: no" >&5
10648 echo "${ECHO_T}no" >&6
10649 fi
10650
10651   done
10652 fi
10653
10654 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10655   for ncn_progname in objdump; do
10656     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10657 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10658     if test -x $with_build_time_tools/${ncn_progname}; then
10659       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10660       echo "$as_me:$LINENO: result: yes" >&5
10661 echo "${ECHO_T}yes" >&6
10662       break
10663     else
10664       echo "$as_me:$LINENO: result: no" >&5
10665 echo "${ECHO_T}no" >&6
10666     fi
10667   done
10668 fi
10669
10670 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10671   for ncn_progname in objdump; do
10672     if test -n "$ncn_target_tool_prefix"; then
10673       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10674 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10675 echo "$as_me:$LINENO: checking for $ac_word" >&5
10676 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10677 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10678   echo $ECHO_N "(cached) $ECHO_C" >&6
10679 else
10680   if test -n "$OBJDUMP_FOR_TARGET"; then
10681   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10682 else
10683 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10684 for as_dir in $PATH
10685 do
10686   IFS=$as_save_IFS
10687   test -z "$as_dir" && as_dir=.
10688   for ac_exec_ext in '' $ac_executable_extensions; do
10689   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10690     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10691     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10692     break 2
10693   fi
10694 done
10695 done
10696
10697 fi
10698 fi
10699 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10700 if test -n "$OBJDUMP_FOR_TARGET"; then
10701   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10702 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10703 else
10704   echo "$as_me:$LINENO: result: no" >&5
10705 echo "${ECHO_T}no" >&6
10706 fi
10707
10708     fi
10709     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10710       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10711 set dummy ${ncn_progname}; ac_word=$2
10712 echo "$as_me:$LINENO: checking for $ac_word" >&5
10713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10714 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10715   echo $ECHO_N "(cached) $ECHO_C" >&6
10716 else
10717   if test -n "$OBJDUMP_FOR_TARGET"; then
10718   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10719 else
10720 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10721 for as_dir in $PATH
10722 do
10723   IFS=$as_save_IFS
10724   test -z "$as_dir" && as_dir=.
10725   for ac_exec_ext in '' $ac_executable_extensions; do
10726   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10727     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10728     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10729     break 2
10730   fi
10731 done
10732 done
10733
10734 fi
10735 fi
10736 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10737 if test -n "$OBJDUMP_FOR_TARGET"; then
10738   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10739 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10740 else
10741   echo "$as_me:$LINENO: result: no" >&5
10742 echo "${ECHO_T}no" >&6
10743 fi
10744
10745     fi
10746     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10747   done
10748 fi
10749
10750 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10751   set dummy objdump
10752   if test $build = $target ; then
10753     OBJDUMP_FOR_TARGET="$2"
10754   else
10755     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10756   fi
10757 else
10758   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10759 fi
10760
10761 else
10762   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10763 fi
10764
10765
10766
10767
10768 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10769   if test -n "$with_build_time_tools"; then
10770     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10771 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10772     if test -x $with_build_time_tools/ranlib; then
10773       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10774       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10775       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10776 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10777     else
10778       echo "$as_me:$LINENO: result: no" >&5
10779 echo "${ECHO_T}no" >&6
10780     fi
10781   elif test $build != $host && test $have_gcc_for_target = yes; then
10782     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10783     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10784     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10785   fi
10786 fi
10787 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10788   # Extract the first word of "ranlib", so it can be a program name with args.
10789 set dummy ranlib; ac_word=$2
10790 echo "$as_me:$LINENO: checking for $ac_word" >&5
10791 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10792 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10793   echo $ECHO_N "(cached) $ECHO_C" >&6
10794 else
10795   case $RANLIB_FOR_TARGET in
10796   [\\/]* | ?:[\\/]*)
10797   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10798   ;;
10799   *)
10800   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10801 for as_dir in $gcc_cv_tool_dirs
10802 do
10803   IFS=$as_save_IFS
10804   test -z "$as_dir" && as_dir=.
10805   for ac_exec_ext in '' $ac_executable_extensions; do
10806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10807     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10809     break 2
10810   fi
10811 done
10812 done
10813
10814   ;;
10815 esac
10816 fi
10817 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10818
10819 if test -n "$RANLIB_FOR_TARGET"; then
10820   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10821 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10822 else
10823   echo "$as_me:$LINENO: result: no" >&5
10824 echo "${ECHO_T}no" >&6
10825 fi
10826
10827 fi
10828 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10829
10830
10831 if test -n "$RANLIB_FOR_TARGET"; then
10832   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10833 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10834   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10835 fi
10836
10837 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10838   for ncn_progname in ranlib; do
10839     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10840 set dummy ${ncn_progname}; ac_word=$2
10841 echo "$as_me:$LINENO: checking for $ac_word" >&5
10842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10843 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10844   echo $ECHO_N "(cached) $ECHO_C" >&6
10845 else
10846   if test -n "$RANLIB_FOR_TARGET"; then
10847   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10848 else
10849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10850 for as_dir in $PATH
10851 do
10852   IFS=$as_save_IFS
10853   test -z "$as_dir" && as_dir=.
10854   for ac_exec_ext in '' $ac_executable_extensions; do
10855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10856     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10858     break 2
10859   fi
10860 done
10861 done
10862
10863 fi
10864 fi
10865 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10866 if test -n "$RANLIB_FOR_TARGET"; then
10867   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10868 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10869 else
10870   echo "$as_me:$LINENO: result: no" >&5
10871 echo "${ECHO_T}no" >&6
10872 fi
10873
10874   done
10875 fi
10876
10877 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10878   for ncn_progname in ranlib; do
10879     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10880 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10881     if test -x $with_build_time_tools/${ncn_progname}; then
10882       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10883       echo "$as_me:$LINENO: result: yes" >&5
10884 echo "${ECHO_T}yes" >&6
10885       break
10886     else
10887       echo "$as_me:$LINENO: result: no" >&5
10888 echo "${ECHO_T}no" >&6
10889     fi
10890   done
10891 fi
10892
10893 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10894   for ncn_progname in ranlib; do
10895     if test -n "$ncn_target_tool_prefix"; then
10896       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10897 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10898 echo "$as_me:$LINENO: checking for $ac_word" >&5
10899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10900 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10901   echo $ECHO_N "(cached) $ECHO_C" >&6
10902 else
10903   if test -n "$RANLIB_FOR_TARGET"; then
10904   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10905 else
10906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10907 for as_dir in $PATH
10908 do
10909   IFS=$as_save_IFS
10910   test -z "$as_dir" && as_dir=.
10911   for ac_exec_ext in '' $ac_executable_extensions; do
10912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10913     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10915     break 2
10916   fi
10917 done
10918 done
10919
10920 fi
10921 fi
10922 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10923 if test -n "$RANLIB_FOR_TARGET"; then
10924   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10925 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10926 else
10927   echo "$as_me:$LINENO: result: no" >&5
10928 echo "${ECHO_T}no" >&6
10929 fi
10930
10931     fi
10932     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10933       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10934 set dummy ${ncn_progname}; ac_word=$2
10935 echo "$as_me:$LINENO: checking for $ac_word" >&5
10936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10937 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10938   echo $ECHO_N "(cached) $ECHO_C" >&6
10939 else
10940   if test -n "$RANLIB_FOR_TARGET"; then
10941   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10942 else
10943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10944 for as_dir in $PATH
10945 do
10946   IFS=$as_save_IFS
10947   test -z "$as_dir" && as_dir=.
10948   for ac_exec_ext in '' $ac_executable_extensions; do
10949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10950     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10952     break 2
10953   fi
10954 done
10955 done
10956
10957 fi
10958 fi
10959 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10960 if test -n "$RANLIB_FOR_TARGET"; then
10961   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10962 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10963 else
10964   echo "$as_me:$LINENO: result: no" >&5
10965 echo "${ECHO_T}no" >&6
10966 fi
10967
10968     fi
10969     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10970   done
10971 fi
10972
10973 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10974   set dummy ranlib
10975   if test $build = $target ; then
10976     RANLIB_FOR_TARGET="$2"
10977   else
10978     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10979   fi
10980 else
10981   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10982 fi
10983
10984 else
10985   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10986 fi
10987
10988
10989
10990
10991 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10992   if test -n "$with_build_time_tools"; then
10993     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10994 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10995     if test -x $with_build_time_tools/strip; then
10996       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10997       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10998       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10999 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11000     else
11001       echo "$as_me:$LINENO: result: no" >&5
11002 echo "${ECHO_T}no" >&6
11003     fi
11004   elif test $build != $host && test $have_gcc_for_target = yes; then
11005     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11006     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11007     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11008   fi
11009 fi
11010 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11011   # Extract the first word of "strip", so it can be a program name with args.
11012 set dummy strip; ac_word=$2
11013 echo "$as_me:$LINENO: checking for $ac_word" >&5
11014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11015 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11016   echo $ECHO_N "(cached) $ECHO_C" >&6
11017 else
11018   case $STRIP_FOR_TARGET in
11019   [\\/]* | ?:[\\/]*)
11020   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11021   ;;
11022   *)
11023   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11024 for as_dir in $gcc_cv_tool_dirs
11025 do
11026   IFS=$as_save_IFS
11027   test -z "$as_dir" && as_dir=.
11028   for ac_exec_ext in '' $ac_executable_extensions; do
11029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11030     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11032     break 2
11033   fi
11034 done
11035 done
11036
11037   ;;
11038 esac
11039 fi
11040 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11041
11042 if test -n "$STRIP_FOR_TARGET"; then
11043   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11044 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11045 else
11046   echo "$as_me:$LINENO: result: no" >&5
11047 echo "${ECHO_T}no" >&6
11048 fi
11049
11050 fi
11051 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11052
11053
11054 if test -n "$STRIP_FOR_TARGET"; then
11055   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11056 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11057   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11058 fi
11059
11060 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11061   for ncn_progname in strip; do
11062     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11063 set dummy ${ncn_progname}; ac_word=$2
11064 echo "$as_me:$LINENO: checking for $ac_word" >&5
11065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11066 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11067   echo $ECHO_N "(cached) $ECHO_C" >&6
11068 else
11069   if test -n "$STRIP_FOR_TARGET"; then
11070   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11071 else
11072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11073 for as_dir in $PATH
11074 do
11075   IFS=$as_save_IFS
11076   test -z "$as_dir" && as_dir=.
11077   for ac_exec_ext in '' $ac_executable_extensions; do
11078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11079     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11081     break 2
11082   fi
11083 done
11084 done
11085
11086 fi
11087 fi
11088 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11089 if test -n "$STRIP_FOR_TARGET"; then
11090   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11091 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11092 else
11093   echo "$as_me:$LINENO: result: no" >&5
11094 echo "${ECHO_T}no" >&6
11095 fi
11096
11097   done
11098 fi
11099
11100 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11101   for ncn_progname in strip; do
11102     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11103 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11104     if test -x $with_build_time_tools/${ncn_progname}; then
11105       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11106       echo "$as_me:$LINENO: result: yes" >&5
11107 echo "${ECHO_T}yes" >&6
11108       break
11109     else
11110       echo "$as_me:$LINENO: result: no" >&5
11111 echo "${ECHO_T}no" >&6
11112     fi
11113   done
11114 fi
11115
11116 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11117   for ncn_progname in strip; do
11118     if test -n "$ncn_target_tool_prefix"; then
11119       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11120 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11121 echo "$as_me:$LINENO: checking for $ac_word" >&5
11122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11123 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11124   echo $ECHO_N "(cached) $ECHO_C" >&6
11125 else
11126   if test -n "$STRIP_FOR_TARGET"; then
11127   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11128 else
11129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11130 for as_dir in $PATH
11131 do
11132   IFS=$as_save_IFS
11133   test -z "$as_dir" && as_dir=.
11134   for ac_exec_ext in '' $ac_executable_extensions; do
11135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11136     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11138     break 2
11139   fi
11140 done
11141 done
11142
11143 fi
11144 fi
11145 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11146 if test -n "$STRIP_FOR_TARGET"; then
11147   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11148 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11149 else
11150   echo "$as_me:$LINENO: result: no" >&5
11151 echo "${ECHO_T}no" >&6
11152 fi
11153
11154     fi
11155     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11156       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11157 set dummy ${ncn_progname}; ac_word=$2
11158 echo "$as_me:$LINENO: checking for $ac_word" >&5
11159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11160 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11161   echo $ECHO_N "(cached) $ECHO_C" >&6
11162 else
11163   if test -n "$STRIP_FOR_TARGET"; then
11164   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11165 else
11166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11167 for as_dir in $PATH
11168 do
11169   IFS=$as_save_IFS
11170   test -z "$as_dir" && as_dir=.
11171   for ac_exec_ext in '' $ac_executable_extensions; do
11172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11173     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11175     break 2
11176   fi
11177 done
11178 done
11179
11180 fi
11181 fi
11182 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11183 if test -n "$STRIP_FOR_TARGET"; then
11184   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11185 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11186 else
11187   echo "$as_me:$LINENO: result: no" >&5
11188 echo "${ECHO_T}no" >&6
11189 fi
11190
11191     fi
11192     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11193   done
11194 fi
11195
11196 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11197   set dummy strip
11198   if test $build = $target ; then
11199     STRIP_FOR_TARGET="$2"
11200   else
11201     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11202   fi
11203 else
11204   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11205 fi
11206
11207 else
11208   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11209 fi
11210
11211
11212
11213
11214 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11215   if test -n "$with_build_time_tools"; then
11216     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11217 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11218     if test -x $with_build_time_tools/windres; then
11219       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11220       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11221       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11222 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11223     else
11224       echo "$as_me:$LINENO: result: no" >&5
11225 echo "${ECHO_T}no" >&6
11226     fi
11227   elif test $build != $host && test $have_gcc_for_target = yes; then
11228     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11229     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11230     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11231   fi
11232 fi
11233 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11234   # Extract the first word of "windres", so it can be a program name with args.
11235 set dummy windres; ac_word=$2
11236 echo "$as_me:$LINENO: checking for $ac_word" >&5
11237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11238 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11239   echo $ECHO_N "(cached) $ECHO_C" >&6
11240 else
11241   case $WINDRES_FOR_TARGET in
11242   [\\/]* | ?:[\\/]*)
11243   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11244   ;;
11245   *)
11246   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11247 for as_dir in $gcc_cv_tool_dirs
11248 do
11249   IFS=$as_save_IFS
11250   test -z "$as_dir" && as_dir=.
11251   for ac_exec_ext in '' $ac_executable_extensions; do
11252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11253     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11255     break 2
11256   fi
11257 done
11258 done
11259
11260   ;;
11261 esac
11262 fi
11263 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11264
11265 if test -n "$WINDRES_FOR_TARGET"; then
11266   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11267 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11268 else
11269   echo "$as_me:$LINENO: result: no" >&5
11270 echo "${ECHO_T}no" >&6
11271 fi
11272
11273 fi
11274 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11275
11276
11277 if test -n "$WINDRES_FOR_TARGET"; then
11278   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11279 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11280   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11281 fi
11282
11283 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11284   for ncn_progname in windres; do
11285     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11286 set dummy ${ncn_progname}; ac_word=$2
11287 echo "$as_me:$LINENO: checking for $ac_word" >&5
11288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11289 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11290   echo $ECHO_N "(cached) $ECHO_C" >&6
11291 else
11292   if test -n "$WINDRES_FOR_TARGET"; then
11293   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11294 else
11295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11296 for as_dir in $PATH
11297 do
11298   IFS=$as_save_IFS
11299   test -z "$as_dir" && as_dir=.
11300   for ac_exec_ext in '' $ac_executable_extensions; do
11301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11302     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11304     break 2
11305   fi
11306 done
11307 done
11308
11309 fi
11310 fi
11311 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11312 if test -n "$WINDRES_FOR_TARGET"; then
11313   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11314 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11315 else
11316   echo "$as_me:$LINENO: result: no" >&5
11317 echo "${ECHO_T}no" >&6
11318 fi
11319
11320   done
11321 fi
11322
11323 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11324   for ncn_progname in windres; do
11325     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11326 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11327     if test -x $with_build_time_tools/${ncn_progname}; then
11328       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11329       echo "$as_me:$LINENO: result: yes" >&5
11330 echo "${ECHO_T}yes" >&6
11331       break
11332     else
11333       echo "$as_me:$LINENO: result: no" >&5
11334 echo "${ECHO_T}no" >&6
11335     fi
11336   done
11337 fi
11338
11339 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11340   for ncn_progname in windres; do
11341     if test -n "$ncn_target_tool_prefix"; then
11342       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11343 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11344 echo "$as_me:$LINENO: checking for $ac_word" >&5
11345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11346 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11347   echo $ECHO_N "(cached) $ECHO_C" >&6
11348 else
11349   if test -n "$WINDRES_FOR_TARGET"; then
11350   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11351 else
11352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11353 for as_dir in $PATH
11354 do
11355   IFS=$as_save_IFS
11356   test -z "$as_dir" && as_dir=.
11357   for ac_exec_ext in '' $ac_executable_extensions; do
11358   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11359     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11361     break 2
11362   fi
11363 done
11364 done
11365
11366 fi
11367 fi
11368 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11369 if test -n "$WINDRES_FOR_TARGET"; then
11370   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11371 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11372 else
11373   echo "$as_me:$LINENO: result: no" >&5
11374 echo "${ECHO_T}no" >&6
11375 fi
11376
11377     fi
11378     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11379       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11380 set dummy ${ncn_progname}; ac_word=$2
11381 echo "$as_me:$LINENO: checking for $ac_word" >&5
11382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11383 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11384   echo $ECHO_N "(cached) $ECHO_C" >&6
11385 else
11386   if test -n "$WINDRES_FOR_TARGET"; then
11387   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11388 else
11389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11390 for as_dir in $PATH
11391 do
11392   IFS=$as_save_IFS
11393   test -z "$as_dir" && as_dir=.
11394   for ac_exec_ext in '' $ac_executable_extensions; do
11395   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11396     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11397     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11398     break 2
11399   fi
11400 done
11401 done
11402
11403 fi
11404 fi
11405 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11406 if test -n "$WINDRES_FOR_TARGET"; then
11407   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11408 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11409 else
11410   echo "$as_me:$LINENO: result: no" >&5
11411 echo "${ECHO_T}no" >&6
11412 fi
11413
11414     fi
11415     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11416   done
11417 fi
11418
11419 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11420   set dummy windres
11421   if test $build = $target ; then
11422     WINDRES_FOR_TARGET="$2"
11423   else
11424     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11425   fi
11426 else
11427   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11428 fi
11429
11430 else
11431   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11432 fi
11433
11434
11435
11436
11437 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11438   if test -n "$with_build_time_tools"; then
11439     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11440 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11441     if test -x $with_build_time_tools/windmc; then
11442       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11443       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11444       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11445 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11446     else
11447       echo "$as_me:$LINENO: result: no" >&5
11448 echo "${ECHO_T}no" >&6
11449     fi
11450   elif test $build != $host && test $have_gcc_for_target = yes; then
11451     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11452     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11453     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11454   fi
11455 fi
11456 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11457   # Extract the first word of "windmc", so it can be a program name with args.
11458 set dummy windmc; ac_word=$2
11459 echo "$as_me:$LINENO: checking for $ac_word" >&5
11460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11461 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11462   echo $ECHO_N "(cached) $ECHO_C" >&6
11463 else
11464   case $WINDMC_FOR_TARGET in
11465   [\\/]* | ?:[\\/]*)
11466   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11467   ;;
11468   *)
11469   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11470 for as_dir in $gcc_cv_tool_dirs
11471 do
11472   IFS=$as_save_IFS
11473   test -z "$as_dir" && as_dir=.
11474   for ac_exec_ext in '' $ac_executable_extensions; do
11475   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11476     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11477     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11478     break 2
11479   fi
11480 done
11481 done
11482
11483   ;;
11484 esac
11485 fi
11486 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11487
11488 if test -n "$WINDMC_FOR_TARGET"; then
11489   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11490 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11491 else
11492   echo "$as_me:$LINENO: result: no" >&5
11493 echo "${ECHO_T}no" >&6
11494 fi
11495
11496 fi
11497 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11498
11499
11500 if test -n "$WINDMC_FOR_TARGET"; then
11501   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11502 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11503   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11504 fi
11505
11506 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11507   for ncn_progname in windmc; do
11508     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11509 set dummy ${ncn_progname}; ac_word=$2
11510 echo "$as_me:$LINENO: checking for $ac_word" >&5
11511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11512 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11513   echo $ECHO_N "(cached) $ECHO_C" >&6
11514 else
11515   if test -n "$WINDMC_FOR_TARGET"; then
11516   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11517 else
11518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11519 for as_dir in $PATH
11520 do
11521   IFS=$as_save_IFS
11522   test -z "$as_dir" && as_dir=.
11523   for ac_exec_ext in '' $ac_executable_extensions; do
11524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11525     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11527     break 2
11528   fi
11529 done
11530 done
11531
11532 fi
11533 fi
11534 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11535 if test -n "$WINDMC_FOR_TARGET"; then
11536   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11537 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11538 else
11539   echo "$as_me:$LINENO: result: no" >&5
11540 echo "${ECHO_T}no" >&6
11541 fi
11542
11543   done
11544 fi
11545
11546 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11547   for ncn_progname in windmc; do
11548     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11549 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11550     if test -x $with_build_time_tools/${ncn_progname}; then
11551       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11552       echo "$as_me:$LINENO: result: yes" >&5
11553 echo "${ECHO_T}yes" >&6
11554       break
11555     else
11556       echo "$as_me:$LINENO: result: no" >&5
11557 echo "${ECHO_T}no" >&6
11558     fi
11559   done
11560 fi
11561
11562 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11563   for ncn_progname in windmc; do
11564     if test -n "$ncn_target_tool_prefix"; then
11565       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11566 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11567 echo "$as_me:$LINENO: checking for $ac_word" >&5
11568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11569 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11570   echo $ECHO_N "(cached) $ECHO_C" >&6
11571 else
11572   if test -n "$WINDMC_FOR_TARGET"; then
11573   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11574 else
11575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11576 for as_dir in $PATH
11577 do
11578   IFS=$as_save_IFS
11579   test -z "$as_dir" && as_dir=.
11580   for ac_exec_ext in '' $ac_executable_extensions; do
11581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11582     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11584     break 2
11585   fi
11586 done
11587 done
11588
11589 fi
11590 fi
11591 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11592 if test -n "$WINDMC_FOR_TARGET"; then
11593   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11594 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11595 else
11596   echo "$as_me:$LINENO: result: no" >&5
11597 echo "${ECHO_T}no" >&6
11598 fi
11599
11600     fi
11601     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11602       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11603 set dummy ${ncn_progname}; ac_word=$2
11604 echo "$as_me:$LINENO: checking for $ac_word" >&5
11605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11606 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11607   echo $ECHO_N "(cached) $ECHO_C" >&6
11608 else
11609   if test -n "$WINDMC_FOR_TARGET"; then
11610   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11611 else
11612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11613 for as_dir in $PATH
11614 do
11615   IFS=$as_save_IFS
11616   test -z "$as_dir" && as_dir=.
11617   for ac_exec_ext in '' $ac_executable_extensions; do
11618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11619     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11621     break 2
11622   fi
11623 done
11624 done
11625
11626 fi
11627 fi
11628 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11629 if test -n "$WINDMC_FOR_TARGET"; then
11630   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11631 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11632 else
11633   echo "$as_me:$LINENO: result: no" >&5
11634 echo "${ECHO_T}no" >&6
11635 fi
11636
11637     fi
11638     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11639   done
11640 fi
11641
11642 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11643   set dummy windmc
11644   if test $build = $target ; then
11645     WINDMC_FOR_TARGET="$2"
11646   else
11647     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11648   fi
11649 else
11650   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11651 fi
11652
11653 else
11654   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11655 fi
11656
11657
11658 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11659
11660 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11661 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11662 if test "x${build}" != "x${host}" ; then
11663   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11664     # We already found the complete path
11665     ac_dir=`dirname $AR_FOR_TARGET`
11666     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11667 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11668   else
11669     # Canadian cross, just use what we found
11670     echo "$as_me:$LINENO: result: pre-installed" >&5
11671 echo "${ECHO_T}pre-installed" >&6
11672   fi
11673 else
11674   ok=yes
11675   case " ${configdirs} " in
11676     *" binutils "*) ;;
11677     *) ok=no ;;
11678   esac
11679
11680   if test $ok = yes; then
11681     # An in-tree tool is available and we can use it
11682     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11683     echo "$as_me:$LINENO: result: just compiled" >&5
11684 echo "${ECHO_T}just compiled" >&6
11685   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11686     # We already found the complete path
11687     ac_dir=`dirname $AR_FOR_TARGET`
11688     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11689 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11690   elif test "x$target" = "x$host"; then
11691     # We can use an host tool
11692     AR_FOR_TARGET='$(AR)'
11693     echo "$as_me:$LINENO: result: host tool" >&5
11694 echo "${ECHO_T}host tool" >&6
11695   else
11696     # We need a cross tool
11697     echo "$as_me:$LINENO: result: pre-installed" >&5
11698 echo "${ECHO_T}pre-installed" >&6
11699   fi
11700 fi
11701
11702 echo "$as_me:$LINENO: checking where to find the target as" >&5
11703 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11704 if test "x${build}" != "x${host}" ; then
11705   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11706     # We already found the complete path
11707     ac_dir=`dirname $AS_FOR_TARGET`
11708     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11709 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11710   else
11711     # Canadian cross, just use what we found
11712     echo "$as_me:$LINENO: result: pre-installed" >&5
11713 echo "${ECHO_T}pre-installed" >&6
11714   fi
11715 else
11716   ok=yes
11717   case " ${configdirs} " in
11718     *" gas "*) ;;
11719     *) ok=no ;;
11720   esac
11721
11722   if test $ok = yes; then
11723     # An in-tree tool is available and we can use it
11724     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11725     echo "$as_me:$LINENO: result: just compiled" >&5
11726 echo "${ECHO_T}just compiled" >&6
11727   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11728     # We already found the complete path
11729     ac_dir=`dirname $AS_FOR_TARGET`
11730     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11731 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11732   elif test "x$target" = "x$host"; then
11733     # We can use an host tool
11734     AS_FOR_TARGET='$(AS)'
11735     echo "$as_me:$LINENO: result: host tool" >&5
11736 echo "${ECHO_T}host tool" >&6
11737   else
11738     # We need a cross tool
11739     echo "$as_me:$LINENO: result: pre-installed" >&5
11740 echo "${ECHO_T}pre-installed" >&6
11741   fi
11742 fi
11743
11744 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11745 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11746 if test "x${build}" != "x${host}" ; then
11747   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11748     # We already found the complete path
11749     ac_dir=`dirname $CC_FOR_TARGET`
11750     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11751 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11752   else
11753     # Canadian cross, just use what we found
11754     echo "$as_me:$LINENO: result: pre-installed" >&5
11755 echo "${ECHO_T}pre-installed" >&6
11756   fi
11757 else
11758   ok=yes
11759   case " ${configdirs} " in
11760     *" gcc "*) ;;
11761     *) ok=no ;;
11762   esac
11763
11764   if test $ok = yes; then
11765     # An in-tree tool is available and we can use it
11766     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11767     echo "$as_me:$LINENO: result: just compiled" >&5
11768 echo "${ECHO_T}just compiled" >&6
11769   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11770     # We already found the complete path
11771     ac_dir=`dirname $CC_FOR_TARGET`
11772     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11773 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11774   elif test "x$target" = "x$host"; then
11775     # We can use an host tool
11776     CC_FOR_TARGET='$(CC)'
11777     echo "$as_me:$LINENO: result: host tool" >&5
11778 echo "${ECHO_T}host tool" >&6
11779   else
11780     # We need a cross tool
11781     echo "$as_me:$LINENO: result: pre-installed" >&5
11782 echo "${ECHO_T}pre-installed" >&6
11783   fi
11784 fi
11785
11786 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11787 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11788 if test "x${build}" != "x${host}" ; then
11789   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11790     # We already found the complete path
11791     ac_dir=`dirname $CXX_FOR_TARGET`
11792     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11793 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11794   else
11795     # Canadian cross, just use what we found
11796     echo "$as_me:$LINENO: result: pre-installed" >&5
11797 echo "${ECHO_T}pre-installed" >&6
11798   fi
11799 else
11800   ok=yes
11801   case " ${configdirs} " in
11802     *" gcc "*) ;;
11803     *) ok=no ;;
11804   esac
11805   case ,${enable_languages}, in
11806     *,c++,*) ;;
11807     *) ok=no ;;
11808   esac
11809   if test $ok = yes; then
11810     # An in-tree tool is available and we can use it
11811     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'
11812     echo "$as_me:$LINENO: result: just compiled" >&5
11813 echo "${ECHO_T}just compiled" >&6
11814   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11815     # We already found the complete path
11816     ac_dir=`dirname $CXX_FOR_TARGET`
11817     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11818 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11819   elif test "x$target" = "x$host"; then
11820     # We can use an host tool
11821     CXX_FOR_TARGET='$(CXX)'
11822     echo "$as_me:$LINENO: result: host tool" >&5
11823 echo "${ECHO_T}host tool" >&6
11824   else
11825     # We need a cross tool
11826     echo "$as_me:$LINENO: result: pre-installed" >&5
11827 echo "${ECHO_T}pre-installed" >&6
11828   fi
11829 fi
11830
11831 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11832 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11833 if test "x${build}" != "x${host}" ; then
11834   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11835     # We already found the complete path
11836     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11837     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11838 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11839   else
11840     # Canadian cross, just use what we found
11841     echo "$as_me:$LINENO: result: pre-installed" >&5
11842 echo "${ECHO_T}pre-installed" >&6
11843   fi
11844 else
11845   ok=yes
11846   case " ${configdirs} " in
11847     *" gcc "*) ;;
11848     *) ok=no ;;
11849   esac
11850   case ,${enable_languages}, in
11851     *,c++,*) ;;
11852     *) ok=no ;;
11853   esac
11854   if test $ok = yes; then
11855     # An in-tree tool is available and we can use it
11856     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'
11857     echo "$as_me:$LINENO: result: just compiled" >&5
11858 echo "${ECHO_T}just compiled" >&6
11859   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11860     # We already found the complete path
11861     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11862     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11863 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11864   elif test "x$target" = "x$host"; then
11865     # We can use an host tool
11866     RAW_CXX_FOR_TARGET='$(CXX)'
11867     echo "$as_me:$LINENO: result: host tool" >&5
11868 echo "${ECHO_T}host tool" >&6
11869   else
11870     # We need a cross tool
11871     echo "$as_me:$LINENO: result: pre-installed" >&5
11872 echo "${ECHO_T}pre-installed" >&6
11873   fi
11874 fi
11875
11876 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11877 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11878 if test "x${build}" != "x${host}" ; then
11879   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11880     # We already found the complete path
11881     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11882     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11883 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11884   else
11885     # Canadian cross, just use what we found
11886     echo "$as_me:$LINENO: result: pre-installed" >&5
11887 echo "${ECHO_T}pre-installed" >&6
11888   fi
11889 else
11890   ok=yes
11891   case " ${configdirs} " in
11892     *" binutils "*) ;;
11893     *) ok=no ;;
11894   esac
11895
11896   if test $ok = yes; then
11897     # An in-tree tool is available and we can use it
11898     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11899     echo "$as_me:$LINENO: result: just compiled" >&5
11900 echo "${ECHO_T}just compiled" >&6
11901   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11902     # We already found the complete path
11903     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11904     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11905 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11906   elif test "x$target" = "x$host"; then
11907     # We can use an host tool
11908     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11909     echo "$as_me:$LINENO: result: host tool" >&5
11910 echo "${ECHO_T}host tool" >&6
11911   else
11912     # We need a cross tool
11913     echo "$as_me:$LINENO: result: pre-installed" >&5
11914 echo "${ECHO_T}pre-installed" >&6
11915   fi
11916 fi
11917
11918 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11919 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11920 if test "x${build}" != "x${host}" ; then
11921   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11922     # We already found the complete path
11923     ac_dir=`dirname $GCC_FOR_TARGET`
11924     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11925 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11926   else
11927     # Canadian cross, just use what we found
11928     echo "$as_me:$LINENO: result: pre-installed" >&5
11929 echo "${ECHO_T}pre-installed" >&6
11930   fi
11931 else
11932   ok=yes
11933   case " ${configdirs} " in
11934     *" gcc "*) ;;
11935     *) ok=no ;;
11936   esac
11937
11938   if test $ok = yes; then
11939     # An in-tree tool is available and we can use it
11940     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11941     echo "$as_me:$LINENO: result: just compiled" >&5
11942 echo "${ECHO_T}just compiled" >&6
11943   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11944     # We already found the complete path
11945     ac_dir=`dirname $GCC_FOR_TARGET`
11946     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11947 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11948   elif test "x$target" = "x$host"; then
11949     # We can use an host tool
11950     GCC_FOR_TARGET='$()'
11951     echo "$as_me:$LINENO: result: host tool" >&5
11952 echo "${ECHO_T}host tool" >&6
11953   else
11954     # We need a cross tool
11955     echo "$as_me:$LINENO: result: pre-installed" >&5
11956 echo "${ECHO_T}pre-installed" >&6
11957   fi
11958 fi
11959
11960 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11961 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11962 if test "x${build}" != "x${host}" ; then
11963   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11964     # We already found the complete path
11965     ac_dir=`dirname $GCJ_FOR_TARGET`
11966     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11967 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11968   else
11969     # Canadian cross, just use what we found
11970     echo "$as_me:$LINENO: result: pre-installed" >&5
11971 echo "${ECHO_T}pre-installed" >&6
11972   fi
11973 else
11974   ok=yes
11975   case " ${configdirs} " in
11976     *" gcc "*) ;;
11977     *) ok=no ;;
11978   esac
11979   case ,${enable_languages}, in
11980     *,java,*) ;;
11981     *) ok=no ;;
11982   esac
11983   if test $ok = yes; then
11984     # An in-tree tool is available and we can use it
11985     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11986     echo "$as_me:$LINENO: result: just compiled" >&5
11987 echo "${ECHO_T}just compiled" >&6
11988   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11989     # We already found the complete path
11990     ac_dir=`dirname $GCJ_FOR_TARGET`
11991     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11992 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11993   elif test "x$target" = "x$host"; then
11994     # We can use an host tool
11995     GCJ_FOR_TARGET='$(GCJ)'
11996     echo "$as_me:$LINENO: result: host tool" >&5
11997 echo "${ECHO_T}host tool" >&6
11998   else
11999     # We need a cross tool
12000     echo "$as_me:$LINENO: result: pre-installed" >&5
12001 echo "${ECHO_T}pre-installed" >&6
12002   fi
12003 fi
12004
12005 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12006 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12007 if test "x${build}" != "x${host}" ; then
12008   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12009     # We already found the complete path
12010     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12011     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12012 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12013   else
12014     # Canadian cross, just use what we found
12015     echo "$as_me:$LINENO: result: pre-installed" >&5
12016 echo "${ECHO_T}pre-installed" >&6
12017   fi
12018 else
12019   ok=yes
12020   case " ${configdirs} " in
12021     *" gcc "*) ;;
12022     *) ok=no ;;
12023   esac
12024   case ,${enable_languages}, in
12025     *,fortran,*) ;;
12026     *) ok=no ;;
12027   esac
12028   if test $ok = yes; then
12029     # An in-tree tool is available and we can use it
12030     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12031     echo "$as_me:$LINENO: result: just compiled" >&5
12032 echo "${ECHO_T}just compiled" >&6
12033   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12034     # We already found the complete path
12035     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12036     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12037 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12038   elif test "x$target" = "x$host"; then
12039     # We can use an host tool
12040     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12041     echo "$as_me:$LINENO: result: host tool" >&5
12042 echo "${ECHO_T}host tool" >&6
12043   else
12044     # We need a cross tool
12045     echo "$as_me:$LINENO: result: pre-installed" >&5
12046 echo "${ECHO_T}pre-installed" >&6
12047   fi
12048 fi
12049
12050 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12051 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12052 if test "x${build}" != "x${host}" ; then
12053   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12054     # We already found the complete path
12055     ac_dir=`dirname $LD_FOR_TARGET`
12056     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12057 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12058   else
12059     # Canadian cross, just use what we found
12060     echo "$as_me:$LINENO: result: pre-installed" >&5
12061 echo "${ECHO_T}pre-installed" >&6
12062   fi
12063 else
12064   ok=yes
12065   case " ${configdirs} " in
12066     *" ld "*) ;;
12067     *) ok=no ;;
12068   esac
12069
12070   if test $ok = yes; then
12071     # An in-tree tool is available and we can use it
12072     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12073     echo "$as_me:$LINENO: result: just compiled" >&5
12074 echo "${ECHO_T}just compiled" >&6
12075   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12076     # We already found the complete path
12077     ac_dir=`dirname $LD_FOR_TARGET`
12078     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12079 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12080   elif test "x$target" = "x$host"; then
12081     # We can use an host tool
12082     LD_FOR_TARGET='$(LD)'
12083     echo "$as_me:$LINENO: result: host tool" >&5
12084 echo "${ECHO_T}host tool" >&6
12085   else
12086     # We need a cross tool
12087     echo "$as_me:$LINENO: result: pre-installed" >&5
12088 echo "${ECHO_T}pre-installed" >&6
12089   fi
12090 fi
12091
12092 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12093 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12094 if test "x${build}" != "x${host}" ; then
12095   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12096     # We already found the complete path
12097     ac_dir=`dirname $LIPO_FOR_TARGET`
12098     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12099 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12100   else
12101     # Canadian cross, just use what we found
12102     echo "$as_me:$LINENO: result: pre-installed" >&5
12103 echo "${ECHO_T}pre-installed" >&6
12104   fi
12105 else
12106   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12107     # We already found the complete path
12108     ac_dir=`dirname $LIPO_FOR_TARGET`
12109     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12110 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12111   elif test "x$target" = "x$host"; then
12112     # We can use an host tool
12113     LIPO_FOR_TARGET='$(LIPO)'
12114     echo "$as_me:$LINENO: result: host tool" >&5
12115 echo "${ECHO_T}host tool" >&6
12116   else
12117     # We need a cross tool
12118     echo "$as_me:$LINENO: result: pre-installed" >&5
12119 echo "${ECHO_T}pre-installed" >&6
12120   fi
12121 fi
12122
12123 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12124 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12125 if test "x${build}" != "x${host}" ; then
12126   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12127     # We already found the complete path
12128     ac_dir=`dirname $NM_FOR_TARGET`
12129     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12130 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12131   else
12132     # Canadian cross, just use what we found
12133     echo "$as_me:$LINENO: result: pre-installed" >&5
12134 echo "${ECHO_T}pre-installed" >&6
12135   fi
12136 else
12137   ok=yes
12138   case " ${configdirs} " in
12139     *" binutils "*) ;;
12140     *) ok=no ;;
12141   esac
12142
12143   if test $ok = yes; then
12144     # An in-tree tool is available and we can use it
12145     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12146     echo "$as_me:$LINENO: result: just compiled" >&5
12147 echo "${ECHO_T}just compiled" >&6
12148   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12149     # We already found the complete path
12150     ac_dir=`dirname $NM_FOR_TARGET`
12151     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12152 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12153   elif test "x$target" = "x$host"; then
12154     # We can use an host tool
12155     NM_FOR_TARGET='$(NM)'
12156     echo "$as_me:$LINENO: result: host tool" >&5
12157 echo "${ECHO_T}host tool" >&6
12158   else
12159     # We need a cross tool
12160     echo "$as_me:$LINENO: result: pre-installed" >&5
12161 echo "${ECHO_T}pre-installed" >&6
12162   fi
12163 fi
12164
12165 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12166 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12167 if test "x${build}" != "x${host}" ; then
12168   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12169     # We already found the complete path
12170     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12171     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12172 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12173   else
12174     # Canadian cross, just use what we found
12175     echo "$as_me:$LINENO: result: pre-installed" >&5
12176 echo "${ECHO_T}pre-installed" >&6
12177   fi
12178 else
12179   ok=yes
12180   case " ${configdirs} " in
12181     *" binutils "*) ;;
12182     *) ok=no ;;
12183   esac
12184
12185   if test $ok = yes; then
12186     # An in-tree tool is available and we can use it
12187     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12188     echo "$as_me:$LINENO: result: just compiled" >&5
12189 echo "${ECHO_T}just compiled" >&6
12190   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12191     # We already found the complete path
12192     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12193     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12194 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12195   elif test "x$target" = "x$host"; then
12196     # We can use an host tool
12197     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12198     echo "$as_me:$LINENO: result: host tool" >&5
12199 echo "${ECHO_T}host tool" >&6
12200   else
12201     # We need a cross tool
12202     echo "$as_me:$LINENO: result: pre-installed" >&5
12203 echo "${ECHO_T}pre-installed" >&6
12204   fi
12205 fi
12206
12207 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12208 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12209 if test "x${build}" != "x${host}" ; then
12210   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12211     # We already found the complete path
12212     ac_dir=`dirname $RANLIB_FOR_TARGET`
12213     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12214 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12215   else
12216     # Canadian cross, just use what we found
12217     echo "$as_me:$LINENO: result: pre-installed" >&5
12218 echo "${ECHO_T}pre-installed" >&6
12219   fi
12220 else
12221   ok=yes
12222   case " ${configdirs} " in
12223     *" binutils "*) ;;
12224     *) ok=no ;;
12225   esac
12226
12227   if test $ok = yes; then
12228     # An in-tree tool is available and we can use it
12229     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12230     echo "$as_me:$LINENO: result: just compiled" >&5
12231 echo "${ECHO_T}just compiled" >&6
12232   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12233     # We already found the complete path
12234     ac_dir=`dirname $RANLIB_FOR_TARGET`
12235     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12236 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12237   elif test "x$target" = "x$host"; then
12238     # We can use an host tool
12239     RANLIB_FOR_TARGET='$(RANLIB)'
12240     echo "$as_me:$LINENO: result: host tool" >&5
12241 echo "${ECHO_T}host tool" >&6
12242   else
12243     # We need a cross tool
12244     echo "$as_me:$LINENO: result: pre-installed" >&5
12245 echo "${ECHO_T}pre-installed" >&6
12246   fi
12247 fi
12248
12249 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12250 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12251 if test "x${build}" != "x${host}" ; then
12252   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12253     # We already found the complete path
12254     ac_dir=`dirname $STRIP_FOR_TARGET`
12255     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12256 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12257   else
12258     # Canadian cross, just use what we found
12259     echo "$as_me:$LINENO: result: pre-installed" >&5
12260 echo "${ECHO_T}pre-installed" >&6
12261   fi
12262 else
12263   ok=yes
12264   case " ${configdirs} " in
12265     *" binutils "*) ;;
12266     *) ok=no ;;
12267   esac
12268
12269   if test $ok = yes; then
12270     # An in-tree tool is available and we can use it
12271     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12272     echo "$as_me:$LINENO: result: just compiled" >&5
12273 echo "${ECHO_T}just compiled" >&6
12274   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12275     # We already found the complete path
12276     ac_dir=`dirname $STRIP_FOR_TARGET`
12277     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12278 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12279   elif test "x$target" = "x$host"; then
12280     # We can use an host tool
12281     STRIP_FOR_TARGET='$(STRIP)'
12282     echo "$as_me:$LINENO: result: host tool" >&5
12283 echo "${ECHO_T}host tool" >&6
12284   else
12285     # We need a cross tool
12286     echo "$as_me:$LINENO: result: pre-installed" >&5
12287 echo "${ECHO_T}pre-installed" >&6
12288   fi
12289 fi
12290
12291 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12292 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12293 if test "x${build}" != "x${host}" ; then
12294   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12295     # We already found the complete path
12296     ac_dir=`dirname $WINDRES_FOR_TARGET`
12297     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12298 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12299   else
12300     # Canadian cross, just use what we found
12301     echo "$as_me:$LINENO: result: pre-installed" >&5
12302 echo "${ECHO_T}pre-installed" >&6
12303   fi
12304 else
12305   ok=yes
12306   case " ${configdirs} " in
12307     *" binutils "*) ;;
12308     *) ok=no ;;
12309   esac
12310
12311   if test $ok = yes; then
12312     # An in-tree tool is available and we can use it
12313     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12314     echo "$as_me:$LINENO: result: just compiled" >&5
12315 echo "${ECHO_T}just compiled" >&6
12316   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12317     # We already found the complete path
12318     ac_dir=`dirname $WINDRES_FOR_TARGET`
12319     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12320 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12321   elif test "x$target" = "x$host"; then
12322     # We can use an host tool
12323     WINDRES_FOR_TARGET='$(WINDRES)'
12324     echo "$as_me:$LINENO: result: host tool" >&5
12325 echo "${ECHO_T}host tool" >&6
12326   else
12327     # We need a cross tool
12328     echo "$as_me:$LINENO: result: pre-installed" >&5
12329 echo "${ECHO_T}pre-installed" >&6
12330   fi
12331 fi
12332
12333 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12334 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12335 if test "x${build}" != "x${host}" ; then
12336   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12337     # We already found the complete path
12338     ac_dir=`dirname $WINDMC_FOR_TARGET`
12339     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12340 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12341   else
12342     # Canadian cross, just use what we found
12343     echo "$as_me:$LINENO: result: pre-installed" >&5
12344 echo "${ECHO_T}pre-installed" >&6
12345   fi
12346 else
12347   ok=yes
12348   case " ${configdirs} " in
12349     *" binutils "*) ;;
12350     *) ok=no ;;
12351   esac
12352
12353   if test $ok = yes; then
12354     # An in-tree tool is available and we can use it
12355     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12356     echo "$as_me:$LINENO: result: just compiled" >&5
12357 echo "${ECHO_T}just compiled" >&6
12358   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12359     # We already found the complete path
12360     ac_dir=`dirname $WINDMC_FOR_TARGET`
12361     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12362 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12363   elif test "x$target" = "x$host"; then
12364     # We can use an host tool
12365     WINDMC_FOR_TARGET='$(WINDMC)'
12366     echo "$as_me:$LINENO: result: host tool" >&5
12367 echo "${ECHO_T}host tool" >&6
12368   else
12369     # We need a cross tool
12370     echo "$as_me:$LINENO: result: pre-installed" >&5
12371 echo "${ECHO_T}pre-installed" >&6
12372   fi
12373 fi
12374
12375
12376
12377
12378
12379 # Certain tools may need extra flags.
12380 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12381 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12382 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12383
12384 # When building target libraries, except in a Canadian cross, we use
12385 # the same toolchain as the compiler we just built.
12386 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12387 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12388 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12389 if test $host = $build; then
12390   case " $configdirs " in
12391     *" gcc "*)
12392       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12393       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12394       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12395       ;;
12396   esac
12397 fi
12398
12399
12400
12401
12402
12403 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12404 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12405 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12406 if test "${enable_maintainer_mode+set}" = set; then
12407   enableval="$enable_maintainer_mode"
12408   USE_MAINTAINER_MODE=$enableval
12409 else
12410   USE_MAINTAINER_MODE=no
12411 fi;
12412 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12413 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12414
12415
12416 if test "$USE_MAINTAINER_MODE" = yes; then
12417   MAINTAINER_MODE_TRUE=
12418   MAINTAINER_MODE_FALSE='#'
12419 else
12420   MAINTAINER_MODE_TRUE='#'
12421   MAINTAINER_MODE_FALSE=
12422 fi
12423 MAINT=$MAINTAINER_MODE_TRUE
12424
12425 # ---------------------
12426 # GCC bootstrap support
12427 # ---------------------
12428
12429 # Stage specific cflags for build.
12430 stage1_cflags="-g"
12431 case $build in
12432   vax-*-*)
12433     case ${GCC} in
12434       yes) stage1_cflags="-g -Wa,-J" ;;
12435       *) stage1_cflags="-g -J" ;;
12436     esac ;;
12437 esac
12438
12439 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12440 if test "$GCC" = yes; then
12441   saved_CFLAGS="$CFLAGS"
12442
12443   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12444   CFLAGS="$CFLAGS -fkeep-inline-functions"
12445   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12446 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12447   cat >conftest.$ac_ext <<_ACEOF
12448 /* confdefs.h.  */
12449 _ACEOF
12450 cat confdefs.h >>conftest.$ac_ext
12451 cat >>conftest.$ac_ext <<_ACEOF
12452 /* end confdefs.h.  */
12453
12454 #if (__GNUC__ < 3) \
12455     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12456                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12457 #error http://gcc.gnu.org/PR29382
12458 #endif
12459
12460 int
12461 main ()
12462 {
12463
12464   ;
12465   return 0;
12466 }
12467 _ACEOF
12468 rm -f conftest.$ac_objext
12469 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12470   (eval $ac_compile) 2>conftest.er1
12471   ac_status=$?
12472   grep -v '^ *+' conftest.er1 >conftest.err
12473   rm -f conftest.er1
12474   cat conftest.err >&5
12475   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12476   (exit $ac_status); } &&
12477          { ac_try='test -z "$ac_c_werror_flag"
12478                          || test ! -s conftest.err'
12479   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12480   (eval $ac_try) 2>&5
12481   ac_status=$?
12482   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12483   (exit $ac_status); }; } &&
12484          { ac_try='test -s conftest.$ac_objext'
12485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12486   (eval $ac_try) 2>&5
12487   ac_status=$?
12488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12489   (exit $ac_status); }; }; then
12490   echo "$as_me:$LINENO: result: yes" >&5
12491 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12492 else
12493   echo "$as_me: failed program was:" >&5
12494 sed 's/^/| /' conftest.$ac_ext >&5
12495
12496 echo "$as_me:$LINENO: result: no" >&5
12497 echo "${ECHO_T}no" >&6
12498 fi
12499 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12500
12501   CFLAGS="$saved_CFLAGS"
12502 fi
12503
12504
12505
12506 # Enable --enable-checking in stage1 of the compiler.
12507 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12508 if test "${enable_stage1_checking+set}" = set; then
12509   enableval="$enable_stage1_checking"
12510   stage1_checking=--enable-checking=${enable_stage1_checking}
12511 else
12512   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12513   stage1_checking=--enable-checking=yes,types
12514 else
12515   stage1_checking=--enable-checking=$enable_checking,types
12516 fi
12517 fi;
12518
12519
12520 # Enable -Werror in bootstrap stage2 and later.
12521 # Check whether --enable-werror or --disable-werror was given.
12522 if test "${enable_werror+set}" = set; then
12523   enableval="$enable_werror"
12524
12525 else
12526   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12527   enable_werror=yes
12528 else
12529   enable_werror=no
12530 fi
12531 fi;
12532 case ${enable_werror} in
12533   yes) stage2_werror_flag="--enable-werror-always" ;;
12534   *) stage2_werror_flag="" ;;
12535 esac
12536
12537
12538 # Flags needed to enable html installing and building
12539
12540 # Check whether --with-datarootdir or --without-datarootdir was given.
12541 if test "${with_datarootdir+set}" = set; then
12542   withval="$with_datarootdir"
12543   datarootdir="\${prefix}/${withval}"
12544 else
12545   datarootdir="\${prefix}/share"
12546 fi;
12547
12548
12549 # Check whether --with-docdir or --without-docdir was given.
12550 if test "${with_docdir+set}" = set; then
12551   withval="$with_docdir"
12552   docdir="\${prefix}/${withval}"
12553 else
12554   docdir="\${datarootdir}/doc"
12555 fi;
12556
12557
12558 # Check whether --with-pdfdir or --without-pdfdir was given.
12559 if test "${with_pdfdir+set}" = set; then
12560   withval="$with_pdfdir"
12561   pdfdir="\${prefix}/${withval}"
12562 else
12563   pdfdir="\${docdir}"
12564 fi;
12565
12566
12567 # Check whether --with-htmldir or --without-htmldir was given.
12568 if test "${with_htmldir+set}" = set; then
12569   withval="$with_htmldir"
12570   htmldir="\${prefix}/${withval}"
12571 else
12572   htmldir="\${docdir}"
12573 fi;
12574
12575
12576
12577
12578
12579
12580           ac_config_files="$ac_config_files Makefile"
12581 cat >confcache <<\_ACEOF
12582 # This file is a shell script that caches the results of configure
12583 # tests run on this system so they can be shared between configure
12584 # scripts and configure runs, see configure's option --config-cache.
12585 # It is not useful on other systems.  If it contains results you don't
12586 # want to keep, you may remove or edit it.
12587 #
12588 # config.status only pays attention to the cache file if you give it
12589 # the --recheck option to rerun configure.
12590 #
12591 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12592 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12593 # following values.
12594
12595 _ACEOF
12596
12597 # The following way of writing the cache mishandles newlines in values,
12598 # but we know of no workaround that is simple, portable, and efficient.
12599 # So, don't put newlines in cache variables' values.
12600 # Ultrix sh set writes to stderr and can't be redirected directly,
12601 # and sets the high bit in the cache file unless we assign to the vars.
12602 {
12603   (set) 2>&1 |
12604     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12605     *ac_space=\ *)
12606       # `set' does not quote correctly, so add quotes (double-quote
12607       # substitution turns \\\\ into \\, and sed turns \\ into \).
12608       sed -n \
12609         "s/'/'\\\\''/g;
12610           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12611       ;;
12612     *)
12613       # `set' quotes correctly as required by POSIX, so do not add quotes.
12614       sed -n \
12615         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12616       ;;
12617     esac;
12618 } |
12619   sed '
12620      t clear
12621      : clear
12622      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12623      t end
12624      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12625      : end' >>confcache
12626 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12627   if test -w $cache_file; then
12628     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12629     cat confcache >$cache_file
12630   else
12631     echo "not updating unwritable cache $cache_file"
12632   fi
12633 fi
12634 rm -f confcache
12635
12636 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12637 # Let make expand exec_prefix.
12638 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12639
12640 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12641 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12642 # trailing colons and then remove the whole line if VPATH becomes empty
12643 # (actually we leave an empty line to preserve line numbers).
12644 if test "x$srcdir" = x.; then
12645   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12646 s/:*\$(srcdir):*/:/;
12647 s/:*\${srcdir}:*/:/;
12648 s/:*@srcdir@:*/:/;
12649 s/^\([^=]*=[     ]*\):*/\1/;
12650 s/:*$//;
12651 s/^[^=]*=[       ]*$//;
12652 }'
12653 fi
12654
12655 # Transform confdefs.h into DEFS.
12656 # Protect against shell expansion while executing Makefile rules.
12657 # Protect against Makefile macro expansion.
12658 #
12659 # If the first sed substitution is executed (which looks for macros that
12660 # take arguments), then we branch to the quote section.  Otherwise,
12661 # look for a macro that doesn't take arguments.
12662 cat >confdef2opt.sed <<\_ACEOF
12663 t clear
12664 : clear
12665 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12666 t quote
12667 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12668 t quote
12669 d
12670 : quote
12671 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12672 s,\[,\\&,g
12673 s,\],\\&,g
12674 s,\$,$$,g
12675 p
12676 _ACEOF
12677 # We use echo to avoid assuming a particular line-breaking character.
12678 # The extra dot is to prevent the shell from consuming trailing
12679 # line-breaks from the sub-command output.  A line-break within
12680 # single-quotes doesn't work because, if this script is created in a
12681 # platform that uses two characters for line-breaks (e.g., DOS), tr
12682 # would break.
12683 ac_LF_and_DOT=`echo; echo .`
12684 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12685 rm -f confdef2opt.sed
12686
12687
12688 ac_libobjs=
12689 ac_ltlibobjs=
12690 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12691   # 1. Remove the extension, and $U if already installed.
12692   ac_i=`echo "$ac_i" |
12693          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12694   # 2. Add them.
12695   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12696   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12697 done
12698 LIBOBJS=$ac_libobjs
12699
12700 LTLIBOBJS=$ac_ltlibobjs
12701
12702
12703
12704 : ${CONFIG_STATUS=./config.status}
12705 ac_clean_files_save=$ac_clean_files
12706 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12707 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12708 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12709 cat >$CONFIG_STATUS <<_ACEOF
12710 #! $SHELL
12711 # Generated by $as_me.
12712 # Run this file to recreate the current configuration.
12713 # Compiler output produced by configure, useful for debugging
12714 # configure, is in config.log if it exists.
12715
12716 debug=false
12717 ac_cs_recheck=false
12718 ac_cs_silent=false
12719 SHELL=\${CONFIG_SHELL-$SHELL}
12720 _ACEOF
12721
12722 cat >>$CONFIG_STATUS <<\_ACEOF
12723 ## --------------------- ##
12724 ## M4sh Initialization.  ##
12725 ## --------------------- ##
12726
12727 # Be Bourne compatible
12728 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12729   emulate sh
12730   NULLCMD=:
12731   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12732   # is contrary to our usage.  Disable this feature.
12733   alias -g '${1+"$@"}'='"$@"'
12734 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12735   set -o posix
12736 fi
12737 DUALCASE=1; export DUALCASE # for MKS sh
12738
12739 # Support unset when possible.
12740 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12741   as_unset=unset
12742 else
12743   as_unset=false
12744 fi
12745
12746
12747 # Work around bugs in pre-3.0 UWIN ksh.
12748 $as_unset ENV MAIL MAILPATH
12749 PS1='$ '
12750 PS2='> '
12751 PS4='+ '
12752
12753 # NLS nuisances.
12754 for as_var in \
12755   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12756   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12757   LC_TELEPHONE LC_TIME
12758 do
12759   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12760     eval $as_var=C; export $as_var
12761   else
12762     $as_unset $as_var
12763   fi
12764 done
12765
12766 # Required to use basename.
12767 if expr a : '\(a\)' >/dev/null 2>&1; then
12768   as_expr=expr
12769 else
12770   as_expr=false
12771 fi
12772
12773 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12774   as_basename=basename
12775 else
12776   as_basename=false
12777 fi
12778
12779
12780 # Name of the executable.
12781 as_me=`$as_basename "$0" ||
12782 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12783          X"$0" : 'X\(//\)$' \| \
12784          X"$0" : 'X\(/\)$' \| \
12785          .     : '\(.\)' 2>/dev/null ||
12786 echo X/"$0" |
12787     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12788           /^X\/\(\/\/\)$/{ s//\1/; q; }
12789           /^X\/\(\/\).*/{ s//\1/; q; }
12790           s/.*/./; q'`
12791
12792
12793 # PATH needs CR, and LINENO needs CR and PATH.
12794 # Avoid depending upon Character Ranges.
12795 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12796 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12797 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12798 as_cr_digits='0123456789'
12799 as_cr_alnum=$as_cr_Letters$as_cr_digits
12800
12801 # The user is always right.
12802 if test "${PATH_SEPARATOR+set}" != set; then
12803   echo "#! /bin/sh" >conf$$.sh
12804   echo  "exit 0"   >>conf$$.sh
12805   chmod +x conf$$.sh
12806   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12807     PATH_SEPARATOR=';'
12808   else
12809     PATH_SEPARATOR=:
12810   fi
12811   rm -f conf$$.sh
12812 fi
12813
12814
12815   as_lineno_1=$LINENO
12816   as_lineno_2=$LINENO
12817   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12818   test "x$as_lineno_1" != "x$as_lineno_2" &&
12819   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12820   # Find who we are.  Look in the path if we contain no path at all
12821   # relative or not.
12822   case $0 in
12823     *[\\/]* ) as_myself=$0 ;;
12824     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12825 for as_dir in $PATH
12826 do
12827   IFS=$as_save_IFS
12828   test -z "$as_dir" && as_dir=.
12829   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12830 done
12831
12832        ;;
12833   esac
12834   # We did not find ourselves, most probably we were run as `sh COMMAND'
12835   # in which case we are not to be found in the path.
12836   if test "x$as_myself" = x; then
12837     as_myself=$0
12838   fi
12839   if test ! -f "$as_myself"; then
12840     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12841 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12842    { (exit 1); exit 1; }; }
12843   fi
12844   case $CONFIG_SHELL in
12845   '')
12846     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12847 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12848 do
12849   IFS=$as_save_IFS
12850   test -z "$as_dir" && as_dir=.
12851   for as_base in sh bash ksh sh5; do
12852          case $as_dir in
12853          /*)
12854            if ("$as_dir/$as_base" -c '
12855   as_lineno_1=$LINENO
12856   as_lineno_2=$LINENO
12857   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12858   test "x$as_lineno_1" != "x$as_lineno_2" &&
12859   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12860              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12861              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12862              CONFIG_SHELL=$as_dir/$as_base
12863              export CONFIG_SHELL
12864              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12865            fi;;
12866          esac
12867        done
12868 done
12869 ;;
12870   esac
12871
12872   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12873   # uniformly replaced by the line number.  The first 'sed' inserts a
12874   # line-number line before each line; the second 'sed' does the real
12875   # work.  The second script uses 'N' to pair each line-number line
12876   # with the numbered line, and appends trailing '-' during
12877   # substitution so that $LINENO is not a special case at line end.
12878   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12879   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12880   sed '=' <$as_myself |
12881     sed '
12882       N
12883       s,$,-,
12884       : loop
12885       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12886       t loop
12887       s,-$,,
12888       s,^['$as_cr_digits']*\n,,
12889     ' >$as_me.lineno &&
12890   chmod +x $as_me.lineno ||
12891     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12892 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12893    { (exit 1); exit 1; }; }
12894
12895   # Don't try to exec as it changes $[0], causing all sort of problems
12896   # (the dirname of $[0] is not the place where we might find the
12897   # original and so on.  Autoconf is especially sensible to this).
12898   . ./$as_me.lineno
12899   # Exit status is that of the last command.
12900   exit
12901 }
12902
12903
12904 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12905   *c*,-n*) ECHO_N= ECHO_C='
12906 ' ECHO_T='      ' ;;
12907   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12908   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12909 esac
12910
12911 if expr a : '\(a\)' >/dev/null 2>&1; then
12912   as_expr=expr
12913 else
12914   as_expr=false
12915 fi
12916
12917 rm -f conf$$ conf$$.exe conf$$.file
12918 echo >conf$$.file
12919 if ln -s conf$$.file conf$$ 2>/dev/null; then
12920   # We could just check for DJGPP; but this test a) works b) is more generic
12921   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12922   if test -f conf$$.exe; then
12923     # Don't use ln at all; we don't have any links
12924     as_ln_s='cp -p'
12925   else
12926     as_ln_s='ln -s'
12927   fi
12928 elif ln conf$$.file conf$$ 2>/dev/null; then
12929   as_ln_s=ln
12930 else
12931   as_ln_s='cp -p'
12932 fi
12933 rm -f conf$$ conf$$.exe conf$$.file
12934
12935 if mkdir -p . 2>/dev/null; then
12936   as_mkdir_p=:
12937 else
12938   test -d ./-p && rmdir ./-p
12939   as_mkdir_p=false
12940 fi
12941
12942 as_executable_p="test -f"
12943
12944 # Sed expression to map a string onto a valid CPP name.
12945 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12946
12947 # Sed expression to map a string onto a valid variable name.
12948 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12949
12950
12951 # IFS
12952 # We need space, tab and new line, in precisely that order.
12953 as_nl='
12954 '
12955 IFS="   $as_nl"
12956
12957 # CDPATH.
12958 $as_unset CDPATH
12959
12960 exec 6>&1
12961
12962 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12963 # report actual input values of CONFIG_FILES etc. instead of their
12964 # values after options handling.  Logging --version etc. is OK.
12965 exec 5>>config.log
12966 {
12967   echo
12968   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12969 ## Running $as_me. ##
12970 _ASBOX
12971 } >&5
12972 cat >&5 <<_CSEOF
12973
12974 This file was extended by $as_me, which was
12975 generated by GNU Autoconf 2.59.  Invocation command line was
12976
12977   CONFIG_FILES    = $CONFIG_FILES
12978   CONFIG_HEADERS  = $CONFIG_HEADERS
12979   CONFIG_LINKS    = $CONFIG_LINKS
12980   CONFIG_COMMANDS = $CONFIG_COMMANDS
12981   $ $0 $@
12982
12983 _CSEOF
12984 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12985 echo >&5
12986 _ACEOF
12987
12988 # Files that config.status was made for.
12989 if test -n "$ac_config_files"; then
12990   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12991 fi
12992
12993 if test -n "$ac_config_headers"; then
12994   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12995 fi
12996
12997 if test -n "$ac_config_links"; then
12998   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12999 fi
13000
13001 if test -n "$ac_config_commands"; then
13002   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13003 fi
13004
13005 cat >>$CONFIG_STATUS <<\_ACEOF
13006
13007 ac_cs_usage="\
13008 \`$as_me' instantiates files from templates according to the
13009 current configuration.
13010
13011 Usage: $0 [OPTIONS] [FILE]...
13012
13013   -h, --help       print this help, then exit
13014   -V, --version    print version number, then exit
13015   -q, --quiet      do not print progress messages
13016   -d, --debug      don't remove temporary files
13017       --recheck    update $as_me by reconfiguring in the same conditions
13018   --file=FILE[:TEMPLATE]
13019                    instantiate the configuration file FILE
13020
13021 Configuration files:
13022 $config_files
13023
13024 Report bugs to <bug-autoconf@gnu.org>."
13025 _ACEOF
13026
13027 cat >>$CONFIG_STATUS <<_ACEOF
13028 ac_cs_version="\\
13029 config.status
13030 configured by $0, generated by GNU Autoconf 2.59,
13031   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13032
13033 Copyright (C) 2003 Free Software Foundation, Inc.
13034 This config.status script is free software; the Free Software Foundation
13035 gives unlimited permission to copy, distribute and modify it."
13036 srcdir=$srcdir
13037 INSTALL="$INSTALL"
13038 _ACEOF
13039
13040 cat >>$CONFIG_STATUS <<\_ACEOF
13041 # If no file are specified by the user, then we need to provide default
13042 # value.  By we need to know if files were specified by the user.
13043 ac_need_defaults=:
13044 while test $# != 0
13045 do
13046   case $1 in
13047   --*=*)
13048     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13049     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13050     ac_shift=:
13051     ;;
13052   -*)
13053     ac_option=$1
13054     ac_optarg=$2
13055     ac_shift=shift
13056     ;;
13057   *) # This is not an option, so the user has probably given explicit
13058      # arguments.
13059      ac_option=$1
13060      ac_need_defaults=false;;
13061   esac
13062
13063   case $ac_option in
13064   # Handling of the options.
13065 _ACEOF
13066 cat >>$CONFIG_STATUS <<\_ACEOF
13067   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13068     ac_cs_recheck=: ;;
13069   --version | --vers* | -V )
13070     echo "$ac_cs_version"; exit 0 ;;
13071   --he | --h)
13072     # Conflict between --help and --header
13073     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13074 Try \`$0 --help' for more information." >&5
13075 echo "$as_me: error: ambiguous option: $1
13076 Try \`$0 --help' for more information." >&2;}
13077    { (exit 1); exit 1; }; };;
13078   --help | --hel | -h )
13079     echo "$ac_cs_usage"; exit 0 ;;
13080   --debug | --d* | -d )
13081     debug=: ;;
13082   --file | --fil | --fi | --f )
13083     $ac_shift
13084     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13085     ac_need_defaults=false;;
13086   --header | --heade | --head | --hea )
13087     $ac_shift
13088     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13089     ac_need_defaults=false;;
13090   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13091   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13092     ac_cs_silent=: ;;
13093
13094   # This is an error.
13095   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13096 Try \`$0 --help' for more information." >&5
13097 echo "$as_me: error: unrecognized option: $1
13098 Try \`$0 --help' for more information." >&2;}
13099    { (exit 1); exit 1; }; } ;;
13100
13101   *) ac_config_targets="$ac_config_targets $1" ;;
13102
13103   esac
13104   shift
13105 done
13106
13107 ac_configure_extra_args=
13108
13109 if $ac_cs_silent; then
13110   exec 6>/dev/null
13111   ac_configure_extra_args="$ac_configure_extra_args --silent"
13112 fi
13113
13114 _ACEOF
13115 cat >>$CONFIG_STATUS <<_ACEOF
13116 if \$ac_cs_recheck; then
13117   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13118   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13119 fi
13120
13121 _ACEOF
13122
13123
13124
13125
13126
13127 cat >>$CONFIG_STATUS <<\_ACEOF
13128 for ac_config_target in $ac_config_targets
13129 do
13130   case "$ac_config_target" in
13131   # Handling of arguments.
13132   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13133   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13134 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13135    { (exit 1); exit 1; }; };;
13136   esac
13137 done
13138
13139 # If the user did not use the arguments to specify the items to instantiate,
13140 # then the envvar interface is used.  Set only those that are not.
13141 # We use the long form for the default assignment because of an extremely
13142 # bizarre bug on SunOS 4.1.3.
13143 if $ac_need_defaults; then
13144   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13145 fi
13146
13147 # Have a temporary directory for convenience.  Make it in the build tree
13148 # simply because there is no reason to put it here, and in addition,
13149 # creating and moving files from /tmp can sometimes cause problems.
13150 # Create a temporary directory, and hook for its removal unless debugging.
13151 $debug ||
13152 {
13153   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13154   trap '{ (exit 1); exit 1; }' 1 2 13 15
13155 }
13156
13157 # Create a (secure) tmp directory for tmp files.
13158
13159 {
13160   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13161   test -n "$tmp" && test -d "$tmp"
13162 }  ||
13163 {
13164   tmp=./confstat$$-$RANDOM
13165   (umask 077 && mkdir $tmp)
13166 } ||
13167 {
13168    echo "$me: cannot create a temporary directory in ." >&2
13169    { (exit 1); exit 1; }
13170 }
13171
13172 _ACEOF
13173
13174 cat >>$CONFIG_STATUS <<_ACEOF
13175
13176 #
13177 # CONFIG_FILES section.
13178 #
13179
13180 # No need to generate the scripts if there are no CONFIG_FILES.
13181 # This happens for instance when ./config.status config.h
13182 if test -n "\$CONFIG_FILES"; then
13183   # Protect against being on the right side of a sed subst in config.status.
13184   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13185    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13186 s,@SHELL@,$SHELL,;t t
13187 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13188 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13189 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13190 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13191 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13192 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13193 s,@exec_prefix@,$exec_prefix,;t t
13194 s,@prefix@,$prefix,;t t
13195 s,@program_transform_name@,$program_transform_name,;t t
13196 s,@bindir@,$bindir,;t t
13197 s,@sbindir@,$sbindir,;t t
13198 s,@libexecdir@,$libexecdir,;t t
13199 s,@datadir@,$datadir,;t t
13200 s,@sysconfdir@,$sysconfdir,;t t
13201 s,@sharedstatedir@,$sharedstatedir,;t t
13202 s,@localstatedir@,$localstatedir,;t t
13203 s,@libdir@,$libdir,;t t
13204 s,@includedir@,$includedir,;t t
13205 s,@oldincludedir@,$oldincludedir,;t t
13206 s,@infodir@,$infodir,;t t
13207 s,@mandir@,$mandir,;t t
13208 s,@build_alias@,$build_alias,;t t
13209 s,@host_alias@,$host_alias,;t t
13210 s,@target_alias@,$target_alias,;t t
13211 s,@DEFS@,$DEFS,;t t
13212 s,@ECHO_C@,$ECHO_C,;t t
13213 s,@ECHO_N@,$ECHO_N,;t t
13214 s,@ECHO_T@,$ECHO_T,;t t
13215 s,@LIBS@,$LIBS,;t t
13216 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13217 s,@build@,$build,;t t
13218 s,@build_cpu@,$build_cpu,;t t
13219 s,@build_vendor@,$build_vendor,;t t
13220 s,@build_os@,$build_os,;t t
13221 s,@build_noncanonical@,$build_noncanonical,;t t
13222 s,@host_noncanonical@,$host_noncanonical,;t t
13223 s,@target_noncanonical@,$target_noncanonical,;t t
13224 s,@host@,$host,;t t
13225 s,@host_cpu@,$host_cpu,;t t
13226 s,@host_vendor@,$host_vendor,;t t
13227 s,@host_os@,$host_os,;t t
13228 s,@target@,$target,;t t
13229 s,@target_cpu@,$target_cpu,;t t
13230 s,@target_vendor@,$target_vendor,;t t
13231 s,@target_os@,$target_os,;t t
13232 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13233 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13234 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13235 s,@LN@,$LN,;t t
13236 s,@LN_S@,$LN_S,;t t
13237 s,@build_libsubdir@,$build_libsubdir,;t t
13238 s,@build_subdir@,$build_subdir,;t t
13239 s,@host_subdir@,$host_subdir,;t t
13240 s,@target_subdir@,$target_subdir,;t t
13241 s,@CC@,$CC,;t t
13242 s,@CFLAGS@,$CFLAGS,;t t
13243 s,@LDFLAGS@,$LDFLAGS,;t t
13244 s,@CPPFLAGS@,$CPPFLAGS,;t t
13245 s,@ac_ct_CC@,$ac_ct_CC,;t t
13246 s,@EXEEXT@,$EXEEXT,;t t
13247 s,@OBJEXT@,$OBJEXT,;t t
13248 s,@CXX@,$CXX,;t t
13249 s,@CXXFLAGS@,$CXXFLAGS,;t t
13250 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13251 s,@GNATBIND@,$GNATBIND,;t t
13252 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13253 s,@GNATMAKE@,$GNATMAKE,;t t
13254 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13255 s,@do_compare@,$do_compare,;t t
13256 s,@gmplibs@,$gmplibs,;t t
13257 s,@gmpinc@,$gmpinc,;t t
13258 s,@ppllibs@,$ppllibs,;t t
13259 s,@pplinc@,$pplinc,;t t
13260 s,@clooglibs@,$clooglibs,;t t
13261 s,@clooginc@,$clooginc,;t t
13262 s,@stage1_languages@,$stage1_languages,;t t
13263 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13264 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13265 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13266 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13267 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13268 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13269 s,@tooldir@,$tooldir,;t t
13270 s,@build_tooldir@,$build_tooldir,;t t
13271 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13272 s,@GDB_TK@,$GDB_TK,;t t
13273 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13274 s,@build_configargs@,$build_configargs,;t t
13275 s,@build_configdirs@,$build_configdirs,;t t
13276 s,@host_configargs@,$host_configargs,;t t
13277 s,@configdirs@,$configdirs,;t t
13278 s,@target_configargs@,$target_configargs,;t t
13279 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13280 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13281 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13282 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13283 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13284 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13285 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13286 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13287 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13288 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13289 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13290 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13291 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13292 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13293 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13294 s,@config_shell@,$config_shell,;t t
13295 s,@YACC@,$YACC,;t t
13296 s,@BISON@,$BISON,;t t
13297 s,@M4@,$M4,;t t
13298 s,@LEX@,$LEX,;t t
13299 s,@FLEX@,$FLEX,;t t
13300 s,@MAKEINFO@,$MAKEINFO,;t t
13301 s,@EXPECT@,$EXPECT,;t t
13302 s,@RUNTEST@,$RUNTEST,;t t
13303 s,@AR@,$AR,;t t
13304 s,@AS@,$AS,;t t
13305 s,@DLLTOOL@,$DLLTOOL,;t t
13306 s,@LD@,$LD,;t t
13307 s,@LIPO@,$LIPO,;t t
13308 s,@NM@,$NM,;t t
13309 s,@RANLIB@,$RANLIB,;t t
13310 s,@STRIP@,$STRIP,;t t
13311 s,@WINDRES@,$WINDRES,;t t
13312 s,@WINDMC@,$WINDMC,;t t
13313 s,@OBJCOPY@,$OBJCOPY,;t t
13314 s,@OBJDUMP@,$OBJDUMP,;t t
13315 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13316 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13317 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13318 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13319 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13320 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13321 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13322 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13323 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13324 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13325 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13326 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13327 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13328 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13329 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13330 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13331 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13332 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13333 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13334 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13335 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13336 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13337 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13338 s,@MAINT@,$MAINT,;t t
13339 s,@stage1_cflags@,$stage1_cflags,;t t
13340 s,@stage1_checking@,$stage1_checking,;t t
13341 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13342 s,@datarootdir@,$datarootdir,;t t
13343 s,@docdir@,$docdir,;t t
13344 s,@pdfdir@,$pdfdir,;t t
13345 s,@htmldir@,$htmldir,;t t
13346 s,@LIBOBJS@,$LIBOBJS,;t t
13347 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13348 /@serialization_dependencies@/r $serialization_dependencies
13349 s,@serialization_dependencies@,,;t t
13350 /@host_makefile_frag@/r $host_makefile_frag
13351 s,@host_makefile_frag@,,;t t
13352 /@target_makefile_frag@/r $target_makefile_frag
13353 s,@target_makefile_frag@,,;t t
13354 /@alphaieee_frag@/r $alphaieee_frag
13355 s,@alphaieee_frag@,,;t t
13356 /@ospace_frag@/r $ospace_frag
13357 s,@ospace_frag@,,;t t
13358 CEOF
13359
13360 _ACEOF
13361
13362   cat >>$CONFIG_STATUS <<\_ACEOF
13363   # Split the substitutions into bite-sized pieces for seds with
13364   # small command number limits, like on Digital OSF/1 and HP-UX.
13365   ac_max_sed_lines=48
13366   ac_sed_frag=1 # Number of current file.
13367   ac_beg=1 # First line for current file.
13368   ac_end=$ac_max_sed_lines # Line after last line for current file.
13369   ac_more_lines=:
13370   ac_sed_cmds=
13371   while $ac_more_lines; do
13372     if test $ac_beg -gt 1; then
13373       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13374     else
13375       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13376     fi
13377     if test ! -s $tmp/subs.frag; then
13378       ac_more_lines=false
13379     else
13380       # The purpose of the label and of the branching condition is to
13381       # speed up the sed processing (if there are no `@' at all, there
13382       # is no need to browse any of the substitutions).
13383       # These are the two extra sed commands mentioned above.
13384       (echo ':t
13385   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13386       if test -z "$ac_sed_cmds"; then
13387         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13388       else
13389         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13390       fi
13391       ac_sed_frag=`expr $ac_sed_frag + 1`
13392       ac_beg=$ac_end
13393       ac_end=`expr $ac_end + $ac_max_sed_lines`
13394     fi
13395   done
13396   if test -z "$ac_sed_cmds"; then
13397     ac_sed_cmds=cat
13398   fi
13399 fi # test -n "$CONFIG_FILES"
13400
13401 _ACEOF
13402 cat >>$CONFIG_STATUS <<\_ACEOF
13403 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13404   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13405   case $ac_file in
13406   - | *:- | *:-:* ) # input from stdin
13407         cat >$tmp/stdin
13408         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13409         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13410   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13411         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13412   * )   ac_file_in=$ac_file.in ;;
13413   esac
13414
13415   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13416   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13417 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13418          X"$ac_file" : 'X\(//\)[^/]' \| \
13419          X"$ac_file" : 'X\(//\)$' \| \
13420          X"$ac_file" : 'X\(/\)' \| \
13421          .     : '\(.\)' 2>/dev/null ||
13422 echo X"$ac_file" |
13423     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13424           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13425           /^X\(\/\/\)$/{ s//\1/; q; }
13426           /^X\(\/\).*/{ s//\1/; q; }
13427           s/.*/./; q'`
13428   { if $as_mkdir_p; then
13429     mkdir -p "$ac_dir"
13430   else
13431     as_dir="$ac_dir"
13432     as_dirs=
13433     while test ! -d "$as_dir"; do
13434       as_dirs="$as_dir $as_dirs"
13435       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13436 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13437          X"$as_dir" : 'X\(//\)[^/]' \| \
13438          X"$as_dir" : 'X\(//\)$' \| \
13439          X"$as_dir" : 'X\(/\)' \| \
13440          .     : '\(.\)' 2>/dev/null ||
13441 echo X"$as_dir" |
13442     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13443           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13444           /^X\(\/\/\)$/{ s//\1/; q; }
13445           /^X\(\/\).*/{ s//\1/; q; }
13446           s/.*/./; q'`
13447     done
13448     test ! -n "$as_dirs" || mkdir $as_dirs
13449   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13450 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13451    { (exit 1); exit 1; }; }; }
13452
13453   ac_builddir=.
13454
13455 if test "$ac_dir" != .; then
13456   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13457   # A "../" for each directory in $ac_dir_suffix.
13458   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13459 else
13460   ac_dir_suffix= ac_top_builddir=
13461 fi
13462
13463 case $srcdir in
13464   .)  # No --srcdir option.  We are building in place.
13465     ac_srcdir=.
13466     if test -z "$ac_top_builddir"; then
13467        ac_top_srcdir=.
13468     else
13469        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13470     fi ;;
13471   [\\/]* | ?:[\\/]* )  # Absolute path.
13472     ac_srcdir=$srcdir$ac_dir_suffix;
13473     ac_top_srcdir=$srcdir ;;
13474   *) # Relative path.
13475     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13476     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13477 esac
13478
13479 # Do not use `cd foo && pwd` to compute absolute paths, because
13480 # the directories may not exist.
13481 case `pwd` in
13482 .) ac_abs_builddir="$ac_dir";;
13483 *)
13484   case "$ac_dir" in
13485   .) ac_abs_builddir=`pwd`;;
13486   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13487   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13488   esac;;
13489 esac
13490 case $ac_abs_builddir in
13491 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13492 *)
13493   case ${ac_top_builddir}. in
13494   .) ac_abs_top_builddir=$ac_abs_builddir;;
13495   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13496   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13497   esac;;
13498 esac
13499 case $ac_abs_builddir in
13500 .) ac_abs_srcdir=$ac_srcdir;;
13501 *)
13502   case $ac_srcdir in
13503   .) ac_abs_srcdir=$ac_abs_builddir;;
13504   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13505   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13506   esac;;
13507 esac
13508 case $ac_abs_builddir in
13509 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13510 *)
13511   case $ac_top_srcdir in
13512   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13513   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13514   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13515   esac;;
13516 esac
13517
13518
13519   case $INSTALL in
13520   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13521   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13522   esac
13523
13524   if test x"$ac_file" != x-; then
13525     { echo "$as_me:$LINENO: creating $ac_file" >&5
13526 echo "$as_me: creating $ac_file" >&6;}
13527     rm -f "$ac_file"
13528   fi
13529   # Let's still pretend it is `configure' which instantiates (i.e., don't
13530   # use $as_me), people would be surprised to read:
13531   #    /* config.h.  Generated by config.status.  */
13532   if test x"$ac_file" = x-; then
13533     configure_input=
13534   else
13535     configure_input="$ac_file.  "
13536   fi
13537   configure_input=$configure_input"Generated from `echo $ac_file_in |
13538                                      sed 's,.*/,,'` by configure."
13539
13540   # First look for the input files in the build tree, otherwise in the
13541   # src tree.
13542   ac_file_inputs=`IFS=:
13543     for f in $ac_file_in; do
13544       case $f in
13545       -) echo $tmp/stdin ;;
13546       [\\/$]*)
13547          # Absolute (can't be DOS-style, as IFS=:)
13548          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13549 echo "$as_me: error: cannot find input file: $f" >&2;}
13550    { (exit 1); exit 1; }; }
13551          echo "$f";;
13552       *) # Relative
13553          if test -f "$f"; then
13554            # Build tree
13555            echo "$f"
13556          elif test -f "$srcdir/$f"; then
13557            # Source tree
13558            echo "$srcdir/$f"
13559          else
13560            # /dev/null tree
13561            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13562 echo "$as_me: error: cannot find input file: $f" >&2;}
13563    { (exit 1); exit 1; }; }
13564          fi;;
13565       esac
13566     done` || { (exit 1); exit 1; }
13567 _ACEOF
13568 cat >>$CONFIG_STATUS <<_ACEOF
13569   sed "$ac_vpsub
13570 $extrasub
13571 _ACEOF
13572 cat >>$CONFIG_STATUS <<\_ACEOF
13573 :t
13574 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13575 s,@configure_input@,$configure_input,;t t
13576 s,@srcdir@,$ac_srcdir,;t t
13577 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13578 s,@top_srcdir@,$ac_top_srcdir,;t t
13579 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13580 s,@builddir@,$ac_builddir,;t t
13581 s,@abs_builddir@,$ac_abs_builddir,;t t
13582 s,@top_builddir@,$ac_top_builddir,;t t
13583 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13584 s,@INSTALL@,$ac_INSTALL,;t t
13585 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13586   rm -f $tmp/stdin
13587   if test x"$ac_file" != x-; then
13588     mv $tmp/out $ac_file
13589   else
13590     cat $tmp/out
13591     rm -f $tmp/out
13592   fi
13593
13594 done
13595 _ACEOF
13596
13597 cat >>$CONFIG_STATUS <<\_ACEOF
13598
13599 { (exit 0); exit 0; }
13600 _ACEOF
13601 chmod +x $CONFIG_STATUS
13602 ac_clean_files=$ac_clean_files_save
13603
13604
13605 # configure is writing to config.log, and then calls config.status.
13606 # config.status does its own redirection, appending to config.log.
13607 # Unfortunately, on DOS this fails, as config.log is still kept open
13608 # by configure, so config.status won't be able to write to it; its
13609 # output is simply discarded.  So we exec the FD to /dev/null,
13610 # effectively closing config.log, so it can be properly (re)opened and
13611 # appended to by config.status.  When coming back to configure, we
13612 # need to make the FD available again.
13613 if test "$no_create" != yes; then
13614   ac_cs_success=:
13615   ac_config_status_args=
13616   test "$silent" = yes &&
13617     ac_config_status_args="$ac_config_status_args --quiet"
13618   exec 5>/dev/null
13619   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13620   exec 5>>config.log
13621   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13622   # would make configure fail if this is the last instruction.
13623   $ac_cs_success || { (exit 1); exit 1; }
13624 fi
13625