configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc extra_mpfr_configure_flags ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-host-libstdcxx=L Use linker arguments L to link with libstdc++
 973                           when linking with PPL
 974   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 975                           Equivalent to --with-ppl-include=PATH/include
 976                           plus --with-ppl-lib=PATH/lib
 977   --with-ppl-include=PATH Specify directory for installed PPL include files
 978   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 979   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 980                           Equivalent to --with-cloog-include=PATH/include
 981                           plus --with-cloog-lib=PATH/lib
 982   --with-cloog-include=PATH Specify directory for installed CLooG include files
 983   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 984   --with-build-sysroot=SYSROOT
 985                           use sysroot as the system root during the build
 986   --with-debug-prefix-map='A=B C=D ...'
 987                              map A to B, C to D ... in debug information
 988   --with-build-time-tools=PATH
 989                           use given path to find target tools during the build
 990   --with-datarootdir      use datarootdir as the data root directory.
 991   --with-docdir           install documentation in this directory.
 992   --with-pdfdir           install pdf in this directory.
 993   --with-htmldir          install html in this directory.
 994
 995 Some influential environment variables:
 996   CC          C compiler command
 997   CFLAGS      C compiler flags
 998   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 999               nonstandard directory <lib dir>
1000   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1001               headers in a nonstandard directory <include dir>
1002   CXX         C++ compiler command
1003   CXXFLAGS    C++ compiler flags
1004   AR          AR for the host
1005   AS          AS for the host
1006   DLLTOOL     DLLTOOL for the host
1007   LD          LD for the host
1008   LIPO        LIPO for the host
1009   NM          NM for the host
1010   RANLIB      RANLIB for the host
1011   STRIP       STRIP for the host
1012   WINDRES     WINDRES for the host
1013   WINDMC      WINDMC for the host
1014   OBJCOPY     OBJCOPY for the host
1015   OBJDUMP     OBJDUMP for the host
1016   CC_FOR_TARGET
1017               CC for the target
1018   CXX_FOR_TARGET
1019               CXX for the target
1020   GCC_FOR_TARGET
1021               GCC for the target
1022   GCJ_FOR_TARGET
1023               GCJ for the target
1024   GFORTRAN_FOR_TARGET
1025               GFORTRAN for the target
1026   AR_FOR_TARGET
1027               AR for the target
1028   AS_FOR_TARGET
1029               AS for the target
1030   DLLTOOL_FOR_TARGET
1031               DLLTOOL for the target
1032   LD_FOR_TARGET
1033               LD for the target
1034   LIPO_FOR_TARGET
1035               LIPO for the target
1036   NM_FOR_TARGET
1037               NM for the target
1038   OBJDUMP_FOR_TARGET
1039               OBJDUMP for the target
1040   RANLIB_FOR_TARGET
1041               RANLIB for the target
1042   STRIP_FOR_TARGET
1043               STRIP for the target
1044   WINDRES_FOR_TARGET
1045               WINDRES for the target
1046   WINDMC_FOR_TARGET
1047               WINDMC for the target
1048
1049 Use these variables to override the choices made by `configure' or to help
1050 it to find libraries and programs with nonstandard names/locations.
1051
1052 _ACEOF
1053 fi
1054
1055 if test "$ac_init_help" = "recursive"; then
1056   # If there are subdirs, report their specific --help.
1057   ac_popdir=`pwd`
1058   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1059     test -d $ac_dir || continue
1060     ac_builddir=.
1061
1062 if test "$ac_dir" != .; then
1063   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1064   # A "../" for each directory in $ac_dir_suffix.
1065   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1066 else
1067   ac_dir_suffix= ac_top_builddir=
1068 fi
1069
1070 case $srcdir in
1071   .)  # No --srcdir option.  We are building in place.
1072     ac_srcdir=.
1073     if test -z "$ac_top_builddir"; then
1074        ac_top_srcdir=.
1075     else
1076        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1077     fi ;;
1078   [\\/]* | ?:[\\/]* )  # Absolute path.
1079     ac_srcdir=$srcdir$ac_dir_suffix;
1080     ac_top_srcdir=$srcdir ;;
1081   *) # Relative path.
1082     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1083     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1084 esac
1085
1086 # Do not use `cd foo && pwd` to compute absolute paths, because
1087 # the directories may not exist.
1088 case `pwd` in
1089 .) ac_abs_builddir="$ac_dir";;
1090 *)
1091   case "$ac_dir" in
1092   .) ac_abs_builddir=`pwd`;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1094   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1099 *)
1100   case ${ac_top_builddir}. in
1101   .) ac_abs_top_builddir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1103   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1104   esac;;
1105 esac
1106 case $ac_abs_builddir in
1107 .) ac_abs_srcdir=$ac_srcdir;;
1108 *)
1109   case $ac_srcdir in
1110   .) ac_abs_srcdir=$ac_abs_builddir;;
1111   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1112   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1113   esac;;
1114 esac
1115 case $ac_abs_builddir in
1116 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1117 *)
1118   case $ac_top_srcdir in
1119   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1120   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1121   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1122   esac;;
1123 esac
1124
1125     cd $ac_dir
1126     # Check for guested configure; otherwise get Cygnus style configure.
1127     if test -f $ac_srcdir/configure.gnu; then
1128       echo
1129       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1130     elif test -f $ac_srcdir/configure; then
1131       echo
1132       $SHELL $ac_srcdir/configure  --help=recursive
1133     elif test -f $ac_srcdir/configure.ac ||
1134            test -f $ac_srcdir/configure.in; then
1135       echo
1136       $ac_configure --help
1137     else
1138       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1139     fi
1140     cd $ac_popdir
1141   done
1142 fi
1143
1144 test -n "$ac_init_help" && exit 0
1145 if $ac_init_version; then
1146   cat <<\_ACEOF
1147
1148 Copyright (C) 2003 Free Software Foundation, Inc.
1149 This configure script is free software; the Free Software Foundation
1150 gives unlimited permission to copy, distribute and modify it.
1151 _ACEOF
1152   exit 0
1153 fi
1154 exec 5>config.log
1155 cat >&5 <<_ACEOF
1156 This file contains any messages produced by compilers while
1157 running configure, to aid debugging if configure makes a mistake.
1158
1159 It was created by $as_me, which was
1160 generated by GNU Autoconf 2.59.  Invocation command line was
1161
1162   $ $0 $@
1163
1164 _ACEOF
1165 {
1166 cat <<_ASUNAME
1167 ## --------- ##
1168 ## Platform. ##
1169 ## --------- ##
1170
1171 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1172 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1173 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1174 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1175 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1176
1177 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1178 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1179
1180 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1181 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1182 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1183 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1184 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1185 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1186 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1187
1188 _ASUNAME
1189
1190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1191 for as_dir in $PATH
1192 do
1193   IFS=$as_save_IFS
1194   test -z "$as_dir" && as_dir=.
1195   echo "PATH: $as_dir"
1196 done
1197
1198 } >&5
1199
1200 cat >&5 <<_ACEOF
1201
1202
1203 ## ----------- ##
1204 ## Core tests. ##
1205 ## ----------- ##
1206
1207 _ACEOF
1208
1209
1210 # Keep a trace of the command line.
1211 # Strip out --no-create and --no-recursion so they do not pile up.
1212 # Strip out --silent because we don't want to record it for future runs.
1213 # Also quote any args containing shell meta-characters.
1214 # Make two passes to allow for proper duplicate-argument suppression.
1215 ac_configure_args=
1216 ac_configure_args0=
1217 ac_configure_args1=
1218 ac_sep=
1219 ac_must_keep_next=false
1220 for ac_pass in 1 2
1221 do
1222   for ac_arg
1223   do
1224     case $ac_arg in
1225     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1226     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1227     | -silent | --silent | --silen | --sile | --sil)
1228       continue ;;
1229     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1230       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1231     esac
1232     case $ac_pass in
1233     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1234     2)
1235       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1236       if test $ac_must_keep_next = true; then
1237         ac_must_keep_next=false # Got value, back to normal.
1238       else
1239         case $ac_arg in
1240           *=* | --config-cache | -C | -disable-* | --disable-* \
1241           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1242           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1243           | -with-* | --with-* | -without-* | --without-* | --x)
1244             case "$ac_configure_args0 " in
1245               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1246             esac
1247             ;;
1248           -* ) ac_must_keep_next=true ;;
1249         esac
1250       fi
1251       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1252       # Get rid of the leading space.
1253       ac_sep=" "
1254       ;;
1255     esac
1256   done
1257 done
1258 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1259 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1260
1261 # When interrupted or exit'd, cleanup temporary files, and complete
1262 # config.log.  We remove comments because anyway the quotes in there
1263 # would cause problems or look ugly.
1264 # WARNING: Be sure not to use single quotes in there, as some shells,
1265 # such as our DU 5.0 friend, will then `close' the trap.
1266 trap 'exit_status=$?
1267   # Save into config.log some information that might help in debugging.
1268   {
1269     echo
1270
1271     cat <<\_ASBOX
1272 ## ---------------- ##
1273 ## Cache variables. ##
1274 ## ---------------- ##
1275 _ASBOX
1276     echo
1277     # The following way of writing the cache mishandles newlines in values,
1278 {
1279   (set) 2>&1 |
1280     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1281     *ac_space=\ *)
1282       sed -n \
1283         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1284           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1285       ;;
1286     *)
1287       sed -n \
1288         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1289       ;;
1290     esac;
1291 }
1292     echo
1293
1294     cat <<\_ASBOX
1295 ## ----------------- ##
1296 ## Output variables. ##
1297 ## ----------------- ##
1298 _ASBOX
1299     echo
1300     for ac_var in $ac_subst_vars
1301     do
1302       eval ac_val=$`echo $ac_var`
1303       echo "$ac_var='"'"'$ac_val'"'"'"
1304     done | sort
1305     echo
1306
1307     if test -n "$ac_subst_files"; then
1308       cat <<\_ASBOX
1309 ## ------------- ##
1310 ## Output files. ##
1311 ## ------------- ##
1312 _ASBOX
1313       echo
1314       for ac_var in $ac_subst_files
1315       do
1316         eval ac_val=$`echo $ac_var`
1317         echo "$ac_var='"'"'$ac_val'"'"'"
1318       done | sort
1319       echo
1320     fi
1321
1322     if test -s confdefs.h; then
1323       cat <<\_ASBOX
1324 ## ----------- ##
1325 ## confdefs.h. ##
1326 ## ----------- ##
1327 _ASBOX
1328       echo
1329       sed "/^$/d" confdefs.h | sort
1330       echo
1331     fi
1332     test "$ac_signal" != 0 &&
1333       echo "$as_me: caught signal $ac_signal"
1334     echo "$as_me: exit $exit_status"
1335   } >&5
1336   rm -f core *.core &&
1337   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1338     exit $exit_status
1339      ' 0
1340 for ac_signal in 1 2 13 15; do
1341   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1342 done
1343 ac_signal=0
1344
1345 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1346 rm -rf conftest* confdefs.h
1347 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1348 echo >confdefs.h
1349
1350 # Predefined preprocessor variables.
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_NAME "$PACKAGE_NAME"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1359 _ACEOF
1360
1361
1362 cat >>confdefs.h <<_ACEOF
1363 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1364 _ACEOF
1365
1366
1367 cat >>confdefs.h <<_ACEOF
1368 #define PACKAGE_STRING "$PACKAGE_STRING"
1369 _ACEOF
1370
1371
1372 cat >>confdefs.h <<_ACEOF
1373 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1374 _ACEOF
1375
1376
1377 # Let the site file select an alternate cache file if it wants to.
1378 # Prefer explicitly selected file to automatically selected ones.
1379 if test -z "$CONFIG_SITE"; then
1380   if test "x$prefix" != xNONE; then
1381     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1382   else
1383     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1384   fi
1385 fi
1386 for ac_site_file in $CONFIG_SITE; do
1387   if test -r "$ac_site_file"; then
1388     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1389 echo "$as_me: loading site script $ac_site_file" >&6;}
1390     sed 's/^/| /' "$ac_site_file" >&5
1391     . "$ac_site_file"
1392   fi
1393 done
1394
1395 if test -r "$cache_file"; then
1396   # Some versions of bash will fail to source /dev/null (special
1397   # files actually), so we avoid doing that.
1398   if test -f "$cache_file"; then
1399     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1400 echo "$as_me: loading cache $cache_file" >&6;}
1401     case $cache_file in
1402       [\\/]* | ?:[\\/]* ) . $cache_file;;
1403       *)                      . ./$cache_file;;
1404     esac
1405   fi
1406 else
1407   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1408 echo "$as_me: creating cache $cache_file" >&6;}
1409   >$cache_file
1410 fi
1411
1412 # Check that the precious variables saved in the cache have kept the same
1413 # value.
1414 ac_cache_corrupted=false
1415 for ac_var in `(set) 2>&1 |
1416                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1417   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1418   eval ac_new_set=\$ac_env_${ac_var}_set
1419   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1420   eval ac_new_val="\$ac_env_${ac_var}_value"
1421   case $ac_old_set,$ac_new_set in
1422     set,)
1423       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1424 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1425       ac_cache_corrupted=: ;;
1426     ,set)
1427       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1428 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1429       ac_cache_corrupted=: ;;
1430     ,);;
1431     *)
1432       if test "x$ac_old_val" != "x$ac_new_val"; then
1433         # differences in whitespace do not lead to failure.
1434         ac_old_val_w=`echo x $ac_old_val`
1435         ac_new_val_w=`echo x $ac_new_val`
1436         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1437           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1438 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1439           ac_cache_corrupted=:
1440         else
1441           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1442 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1443           eval $ac_var=\$ac_old_val
1444         fi
1445         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1446 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1447         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1448 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1449       fi;;
1450   esac
1451   # Pass precious variables to config.status.
1452   if test "$ac_new_set" = set; then
1453     case $ac_new_val in
1454     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1455       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1456     *) ac_arg=$ac_var=$ac_new_val ;;
1457     esac
1458     case " $ac_configure_args " in
1459       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1460       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1461     esac
1462   fi
1463 done
1464 if $ac_cache_corrupted; then
1465   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1466 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1467   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1468 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1469   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1470 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1471    { (exit 1); exit 1; }; }
1472 fi
1473
1474 ac_ext=c
1475 ac_cpp='$CPP $CPPFLAGS'
1476 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1477 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1478 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503 progname=$0
1504 # if PWD already has a value, it is probably wrong.
1505 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1506
1507 # Export original configure arguments for use by sub-configures.
1508 # Quote arguments with shell meta charatcers.
1509 TOPLEVEL_CONFIGURE_ARGUMENTS=
1510 set -- "$progname" "$@"
1511 for ac_arg
1512 do
1513   case "$ac_arg" in
1514   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1515     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1516     # if the argument is of the form -foo=baz, quote the baz part only
1517     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1518   *) ;;
1519   esac
1520   # Add the quoted argument to the list.
1521   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1522 done
1523 if test "$silent" = yes; then
1524   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1525 fi
1526 # Remove the initial space we just introduced and, as these will be
1527 # expanded by make, quote '$'.
1528 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1529
1530
1531 # Find the build, host, and target systems.
1532 ac_aux_dir=
1533 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1534   if test -f $ac_dir/install-sh; then
1535     ac_aux_dir=$ac_dir
1536     ac_install_sh="$ac_aux_dir/install-sh -c"
1537     break
1538   elif test -f $ac_dir/install.sh; then
1539     ac_aux_dir=$ac_dir
1540     ac_install_sh="$ac_aux_dir/install.sh -c"
1541     break
1542   elif test -f $ac_dir/shtool; then
1543     ac_aux_dir=$ac_dir
1544     ac_install_sh="$ac_aux_dir/shtool install -c"
1545     break
1546   fi
1547 done
1548 if test -z "$ac_aux_dir"; then
1549   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1550 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1551    { (exit 1); exit 1; }; }
1552 fi
1553 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1554 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1555 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1556
1557 # Make sure we can run config.sub.
1558 $ac_config_sub sun4 >/dev/null 2>&1 ||
1559   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1560 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1561    { (exit 1); exit 1; }; }
1562
1563 echo "$as_me:$LINENO: checking build system type" >&5
1564 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1565 if test "${ac_cv_build+set}" = set; then
1566   echo $ECHO_N "(cached) $ECHO_C" >&6
1567 else
1568   ac_cv_build_alias=$build_alias
1569 test -z "$ac_cv_build_alias" &&
1570   ac_cv_build_alias=`$ac_config_guess`
1571 test -z "$ac_cv_build_alias" &&
1572   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1573 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1574    { (exit 1); exit 1; }; }
1575 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1576   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1577 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1578    { (exit 1); exit 1; }; }
1579
1580 fi
1581 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1582 echo "${ECHO_T}$ac_cv_build" >&6
1583 build=$ac_cv_build
1584 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1585 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1586 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1587
1588
1589  case ${build_alias} in
1590   "") build_noncanonical=${build} ;;
1591   *) build_noncanonical=${build_alias} ;;
1592 esac
1593
1594
1595
1596  case ${host_alias} in
1597   "") host_noncanonical=${build_noncanonical} ;;
1598   *) host_noncanonical=${host_alias} ;;
1599 esac
1600
1601
1602
1603  case ${target_alias} in
1604   "") target_noncanonical=${host_noncanonical} ;;
1605   *) target_noncanonical=${target_alias} ;;
1606 esac
1607
1608
1609
1610
1611 test "$host_noncanonical" = "$target_noncanonical" &&
1612   test "$program_prefix$program_suffix$program_transform_name" = \
1613     NONENONEs,x,x, &&
1614   program_transform_name=s,y,y,
1615
1616 echo "$as_me:$LINENO: checking host system type" >&5
1617 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1618 if test "${ac_cv_host+set}" = set; then
1619   echo $ECHO_N "(cached) $ECHO_C" >&6
1620 else
1621   ac_cv_host_alias=$host_alias
1622 test -z "$ac_cv_host_alias" &&
1623   ac_cv_host_alias=$ac_cv_build_alias
1624 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1625   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1626 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1627    { (exit 1); exit 1; }; }
1628
1629 fi
1630 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1631 echo "${ECHO_T}$ac_cv_host" >&6
1632 host=$ac_cv_host
1633 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1634 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1635 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1636
1637
1638 echo "$as_me:$LINENO: checking target system type" >&5
1639 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1640 if test "${ac_cv_target+set}" = set; then
1641   echo $ECHO_N "(cached) $ECHO_C" >&6
1642 else
1643   ac_cv_target_alias=$target_alias
1644 test "x$ac_cv_target_alias" = "x" &&
1645   ac_cv_target_alias=$ac_cv_host_alias
1646 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1647   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1648 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1649    { (exit 1); exit 1; }; }
1650
1651 fi
1652 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1653 echo "${ECHO_T}$ac_cv_target" >&6
1654 target=$ac_cv_target
1655 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1656 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1657 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1658
1659
1660 # The aliases save the names the user supplied, while $host etc.
1661 # will get canonicalized.
1662 test -n "$target_alias" &&
1663   test "$program_prefix$program_suffix$program_transform_name" = \
1664     NONENONEs,x,x, &&
1665   program_prefix=${target_alias}-
1666 test "$program_prefix" != NONE &&
1667   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1668 # Use a double $ so make ignores it.
1669 test "$program_suffix" != NONE &&
1670   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1671 # Double any \ or $.  echo might interpret backslashes.
1672 # By default was `s,x,x', remove it if useless.
1673 cat <<\_ACEOF >conftest.sed
1674 s/[\\$]/&&/g;s/;s,x,x,$//
1675 _ACEOF
1676 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1677 rm conftest.sed
1678
1679
1680
1681 # Get 'install' or 'install-sh' and its variants.
1682 # Find a good install program.  We prefer a C program (faster),
1683 # so one script is as good as another.  But avoid the broken or
1684 # incompatible versions:
1685 # SysV /etc/install, /usr/sbin/install
1686 # SunOS /usr/etc/install
1687 # IRIX /sbin/install
1688 # AIX /bin/install
1689 # AmigaOS /C/install, which installs bootblocks on floppy discs
1690 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1691 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1692 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1693 # OS/2's system install, which has a completely different semantic
1694 # ./install, which can be erroneously created by make from ./install.sh.
1695 # Reject install programs that cannot install multiple files.
1696 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1697 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1698 if test -z "$INSTALL"; then
1699 if test "${ac_cv_path_install+set}" = set; then
1700   echo $ECHO_N "(cached) $ECHO_C" >&6
1701 else
1702   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1703 for as_dir in $PATH
1704 do
1705   IFS=$as_save_IFS
1706   test -z "$as_dir" && as_dir=.
1707   # Account for people who put trailing slashes in PATH elements.
1708 case $as_dir/ in
1709   ./ | .// | /cC/* | \
1710   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1711   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1712   /usr/ucb/* ) ;;
1713   *)
1714     # OSF1 and SCO ODT 3.0 have their own names for install.
1715     # Don't use installbsd from OSF since it installs stuff as root
1716     # by default.
1717     for ac_prog in ginstall scoinst install; do
1718       for ac_exec_ext in '' $ac_executable_extensions; do
1719         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1720           if test $ac_prog = install &&
1721             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1722             # AIX install.  It has an incompatible calling convention.
1723             :
1724           elif test $ac_prog = install &&
1725             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1726             # program-specific install script used by HP pwplus--don't use.
1727             :
1728           else
1729             rm -rf conftest.one conftest.two conftest.dir
1730             echo one > conftest.one
1731             echo two > conftest.two
1732             mkdir conftest.dir
1733             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1734               test -s conftest.one && test -s conftest.two &&
1735               test -s conftest.dir/conftest.one &&
1736               test -s conftest.dir/conftest.two
1737             then
1738               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1739               break 3
1740             fi
1741           fi
1742         fi
1743       done
1744     done
1745     ;;
1746 esac
1747 done
1748
1749 rm -rf conftest.one conftest.two conftest.dir
1750
1751 fi
1752   if test "${ac_cv_path_install+set}" = set; then
1753     INSTALL=$ac_cv_path_install
1754   else
1755     # As a last resort, use the slow shell script.  Don't cache a
1756     # value for INSTALL within a source directory, because that will
1757     # break other packages using the cache if that directory is
1758     # removed, or if the value is a relative name.
1759     INSTALL=$ac_install_sh
1760   fi
1761 fi
1762 echo "$as_me:$LINENO: result: $INSTALL" >&5
1763 echo "${ECHO_T}$INSTALL" >&6
1764
1765 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1766 # It thinks the first close brace ends the variable substitution.
1767 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1768
1769 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1770
1771 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1772
1773 echo "$as_me:$LINENO: checking whether ln works" >&5
1774 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1775 if test "${acx_cv_prog_LN+set}" = set; then
1776   echo $ECHO_N "(cached) $ECHO_C" >&6
1777 else
1778   rm -f conftestdata_t
1779 echo >conftestdata_f
1780 if ln conftestdata_f conftestdata_t 2>/dev/null
1781 then
1782   acx_cv_prog_LN=ln
1783 else
1784   acx_cv_prog_LN=no
1785 fi
1786 rm -f conftestdata_f conftestdata_t
1787
1788 fi
1789 if test $acx_cv_prog_LN = no; then
1790   LN="cp"
1791   echo "$as_me:$LINENO: result: no, using $LN" >&5
1792 echo "${ECHO_T}no, using $LN" >&6
1793 else
1794   LN="$acx_cv_prog_LN"
1795   echo "$as_me:$LINENO: result: yes" >&5
1796 echo "${ECHO_T}yes" >&6
1797 fi
1798
1799 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1800 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1801 LN_S=$as_ln_s
1802 if test "$LN_S" = "ln -s"; then
1803   echo "$as_me:$LINENO: result: yes" >&5
1804 echo "${ECHO_T}yes" >&6
1805 else
1806   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1807 echo "${ECHO_T}no, using $LN_S" >&6
1808 fi
1809
1810
1811 ### we might need to use some other shell than /bin/sh for running subshells
1812 ### If we are on Windows, search for the shell.  This will permit people
1813 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1814 ### without also having to set CONFIG_SHELL.  This code will work when
1815 ### using bash, which sets OSTYPE.
1816 case "${OSTYPE}" in
1817 *win32*)
1818   if test x${CONFIG_SHELL} = x ; then
1819     if test ! -f /bin/sh ; then
1820       if test x${SHELL} != x && test -f ${SHELL} ; then
1821         CONFIG_SHELL=${SHELL}
1822         export CONFIG_SHELL
1823       else
1824         for prog in sh sh.exe bash bash.exe; do
1825           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1826           for dir in $PATH; do
1827             test -z "$dir" && dir=.
1828             if test -f $dir/$prog; then
1829               CONFIG_SHELL=$dir/$prog
1830               export CONFIG_SHELL
1831               break
1832             fi
1833           done
1834           IFS="$save_ifs"
1835           test -n "${CONFIG_SHELL}" && break
1836         done
1837       fi
1838     fi
1839   fi
1840   ;;
1841 esac
1842
1843 config_shell=${CONFIG_SHELL-/bin/sh}
1844
1845 moveifchange=${srcdir}/move-if-change
1846
1847 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1848
1849 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1850 # a relative path.
1851 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1852   INSTALL="${srcpwd}/install-sh -c"
1853 fi
1854
1855 # Set srcdir to "." if that's what it is.
1856 # This is important for multilib support.
1857 pwd=`${PWDCMD-pwd}`
1858 if test "${pwd}" = "${srcpwd}" ; then
1859   srcdir=.
1860 fi
1861
1862 topsrcdir=$srcpwd
1863
1864 extra_host_args=
1865
1866 ### To add a new directory to the tree, first choose whether it is a target
1867 ### or a host dependent tool.  Then put it into the appropriate list
1868 ### (library or tools, host or target), doing a dependency sort.
1869
1870 # Subdirs will be configured in the order listed in build_configdirs,
1871 # configdirs, or target_configdirs; see the serialization section below.
1872
1873 # Dependency sorting is only needed when *configuration* must be done in
1874 # a particular order.  In all cases a dependency should be specified in
1875 # the Makefile, whether or not it's implicitly specified here.
1876
1877 # Double entries in build_configdirs, configdirs, or target_configdirs may
1878 # cause circular dependencies and break everything horribly.
1879
1880 # these library is used by various programs built for the build
1881 # environment
1882 #
1883 build_libs="build-libiberty"
1884
1885 # these tools are built for the build environment
1886 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1887
1888 # these libraries are used by various programs built for the host environment
1889 #
1890 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog libiconv"
1891
1892 # these tools are built for the host environment
1893 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1894 # know that we are building the simulator.
1895 # binutils, gas and ld appear in that order because it makes sense to run
1896 # "make check" in that particular order.
1897 # If --enable-gold is used, "gold" will replace "ld".
1898 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1899
1900 # libgcj represents the runtime libraries only used by gcj.
1901 libgcj="target-libffi \
1902         target-zlib \
1903         target-qthreads \
1904         target-libjava"
1905
1906 # these libraries are built for the target environment, and are built after
1907 # the host libraries and the host tools (which may be a cross compiler)
1908 #
1909 target_libraries="target-libgcc \
1910                 target-libiberty \
1911                 target-libgloss \
1912                 target-newlib \
1913                 target-libgomp \
1914                 target-libstdc++-v3 \
1915                 target-libmudflap \
1916                 target-libssp \
1917                 target-libgfortran \
1918                 target-boehm-gc \
1919                 ${libgcj} \
1920                 target-libobjc \
1921                 target-libada"
1922
1923 # these tools are built using the target libraries, and are intended to
1924 # run only in the target environment
1925 #
1926 # note: any program that *uses* libraries that are in the "target_libraries"
1927 # list belongs in this list.  those programs are also very likely
1928 # candidates for the "native_only" list which follows
1929 #
1930 target_tools="target-examples target-groff target-gperf target-rda"
1931
1932 ################################################################################
1933
1934 ## All tools belong in one of the four categories, and are assigned above
1935 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1936 ## is important because configure will choke if they ever get through.
1937 ## ${configdirs} is directories we build using the host tools.
1938 ## ${target_configdirs} is directories we build using the target tools.
1939 configdirs=`echo ${host_libs} ${host_tools}`
1940 target_configdirs=`echo ${target_libraries} ${target_tools}`
1941 build_configdirs=`echo ${build_libs} ${build_tools}`
1942
1943
1944
1945 ################################################################################
1946
1947 srcname="gnu development package"
1948
1949 # This gets set non-empty for some net releases of packages.
1950 appdirs=""
1951
1952 # Define is_cross_compiler to save on calls to 'test'.
1953 is_cross_compiler=
1954 if test x"${host}" = x"${target}" ; then
1955   is_cross_compiler=no
1956 else
1957   is_cross_compiler=yes
1958 fi
1959
1960 # Find the build and target subdir names.
1961
1962 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1963 # have matching libraries, they should use host libraries: Makefile.tpl
1964 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1965 # However, they still use the build modules, because the corresponding
1966 # host modules (e.g. bison) are only built for the host when bootstrap
1967 # finishes. So:
1968 # - build_subdir is where we find build modules, and never changes.
1969 # - build_libsubdir is where we find build libraries, and can be overridden.
1970
1971 # Prefix 'build-' so this never conflicts with target_subdir.
1972 build_subdir="build-${build_noncanonical}"
1973
1974 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1975 if test "${with_build_libsubdir+set}" = set; then
1976   withval="$with_build_libsubdir"
1977   build_libsubdir="$withval"
1978 else
1979   build_libsubdir="$build_subdir"
1980 fi;
1981 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1982 if ( test $srcdir = . && test -d gcc ) \
1983    || test -d $srcdir/../host-${host_noncanonical}; then
1984   host_subdir="host-${host_noncanonical}"
1985 else
1986   host_subdir=.
1987 fi
1988 # No prefix.
1989 target_subdir=${target_noncanonical}
1990
1991
1992 # Skipdirs are removed silently.
1993 skipdirs=
1994 # Noconfigdirs are removed loudly.
1995 noconfigdirs=""
1996
1997 use_gnu_ld=
1998 # Make sure we don't let GNU ld be added if we didn't want it.
1999 if test x$with_gnu_ld = xno ; then
2000   use_gnu_ld=no
2001   noconfigdirs="$noconfigdirs ld gold"
2002 fi
2003
2004 use_gnu_as=
2005 # Make sure we don't let GNU as be added if we didn't want it.
2006 if test x$with_gnu_as = xno ; then
2007   use_gnu_as=no
2008   noconfigdirs="$noconfigdirs gas"
2009 fi
2010
2011 # some tools are so dependent upon X11 that if we're not building with X,
2012 # it's not even worth trying to configure, much less build, that tool.
2013
2014 case ${with_x} in
2015   yes | "") ;; # the default value for this tree is that X11 is available
2016   no)
2017     skipdirs="${skipdirs} tk itcl libgui"
2018     # We won't be able to build gdbtk without X.
2019     enable_gdbtk=no
2020     ;;
2021   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2022 esac
2023
2024 # Some tools are only suitable for building in a "native" situation.
2025 # Remove these if host!=target.
2026 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2027
2028 # Similarly, some are only suitable for cross toolchains.
2029 # Remove these if host=target.
2030 cross_only="target-libgloss target-newlib target-opcodes"
2031
2032 case $is_cross_compiler in
2033   no) skipdirs="${skipdirs} ${cross_only}" ;;
2034   yes) skipdirs="${skipdirs} ${native_only}" ;;
2035 esac
2036
2037 # If both --with-headers and --with-libs are specified, default to
2038 # --without-newlib.
2039 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2040    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2041   if test x"${with_newlib}" = x ; then
2042     with_newlib=no
2043   fi
2044 fi
2045
2046 # Recognize --with-newlib/--without-newlib.
2047 case ${with_newlib} in
2048   no) skipdirs="${skipdirs} target-newlib" ;;
2049   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2050 esac
2051
2052 # Handle --enable-gold.
2053
2054 # Check whether --enable-gold or --disable-gold was given.
2055 if test "${enable_gold+set}" = set; then
2056   enableval="$enable_gold"
2057   ENABLE_GOLD=$enableval
2058 else
2059   ENABLE_GOLD=no
2060 fi;
2061 if test "${ENABLE_GOLD}" = "yes"; then
2062   # Check for ELF target.
2063   is_elf=no
2064   case "${target}" in
2065     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2066     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2067     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2068       case "${target}" in
2069         *-*-linux*aout* | *-*-linux*oldld*)
2070           ;;
2071         *)
2072           is_elf=yes
2073           ;;
2074       esac
2075   esac
2076
2077   if test "$is_elf" = "yes"; then
2078     # Check for target supported by gold.
2079     case "${target}" in
2080       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2081         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2082         ;;
2083     esac
2084   fi
2085 fi
2086
2087 # Configure extra directories which are host specific
2088
2089 case "${host}" in
2090   *-cygwin*)
2091     configdirs="$configdirs libtermcap" ;;
2092 esac
2093
2094 # A target can indicate whether a language isn't supported for some reason.
2095 # Only spaces may be used in this macro; not newlines or tabs.
2096 unsupported_languages=
2097
2098 # Remove more programs from consideration, based on the host or
2099 # target this usually means that a port of the program doesn't
2100 # exist yet.
2101
2102 case "${host}" in
2103   hppa*64*-*-*)
2104     noconfigdirs="$noconfigdirs byacc"
2105     ;;
2106   i[3456789]86-*-vsta)
2107     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2108     ;;
2109   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2110     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2111     ;;
2112   x86_64-*-mingw*)
2113     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2114     ;;
2115   i[3456789]86-*-mingw32*)
2116     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2117     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2118     ;;
2119   i[3456789]86-*-beos*)
2120     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2121     ;;
2122   *-*-cygwin*)
2123     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2124     ;;
2125   *-*-netbsd*)
2126     noconfigdirs="$noconfigdirs rcs"
2127     ;;
2128   ppc*-*-pe)
2129     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2130     ;;
2131   powerpc-*-beos*)
2132     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2133     ;;
2134 esac
2135
2136
2137 # Check whether --enable-libada or --disable-libada was given.
2138 if test "${enable_libada+set}" = set; then
2139   enableval="$enable_libada"
2140   ENABLE_LIBADA=$enableval
2141 else
2142   ENABLE_LIBADA=yes
2143 fi;
2144 if test "${ENABLE_LIBADA}" != "yes" ; then
2145   noconfigdirs="$noconfigdirs gnattools"
2146 fi
2147
2148 # Check whether --enable-libssp or --disable-libssp was given.
2149 if test "${enable_libssp+set}" = set; then
2150   enableval="$enable_libssp"
2151   ENABLE_LIBSSP=$enableval
2152 else
2153   ENABLE_LIBSSP=yes
2154 fi;
2155
2156 # Save it here so that, even in case of --enable-libgcj, if the Java
2157 # front-end isn't enabled, we still get libgcj disabled.
2158 libgcj_saved=$libgcj
2159 case $enable_libgcj in
2160 yes)
2161   # If we reset it here, it won't get added to noconfigdirs in the
2162   # target-specific build rules, so it will be forcibly enabled
2163   # (unless the Java language itself isn't enabled).
2164   libgcj=
2165   ;;
2166 no)
2167   # Make sure we get it printed in the list of not supported target libs.
2168   noconfigdirs="$noconfigdirs ${libgcj}"
2169   ;;
2170 esac
2171
2172
2173 # Disable libmudflap on some systems.
2174 if test x$enable_libmudflap = x ; then
2175     case "${target}" in
2176     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2177         # Enable libmudflap by default in GNU and friends.
2178         ;;
2179     *-*-freebsd*)
2180         # Enable libmudflap by default in FreeBSD.
2181         ;;
2182     *)
2183         # Disable it by default everywhere else.
2184         noconfigdirs="$noconfigdirs target-libmudflap"
2185         ;;
2186     esac
2187 fi
2188
2189 # Disable libgomp on non POSIX hosted systems.
2190 if test x$enable_libgomp = x ; then
2191     # Enable libgomp by default on hosted POSIX systems.
2192     case "${target}" in
2193     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2194         ;;
2195     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2196         ;;
2197     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2198         ;;
2199     *-*-darwin* | *-*-aix*)
2200         ;;
2201     *)
2202         noconfigdirs="$noconfigdirs target-libgomp"
2203         ;;
2204     esac
2205 fi
2206
2207 # Default libgloss CPU subdirectory.
2208 libgloss_dir="$target_cpu"
2209
2210 case "${target}" in
2211   *-*-chorusos)
2212     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2213     ;;
2214   powerpc-*-darwin*)
2215     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2216     noconfigdirs="$noconfigdirs sim target-rda"
2217     ;;
2218   i[3456789]86-*-darwin* | x86_64-*-darwin[912]*)
2219     noconfigdirs="$noconfigdirs ld gas gprof"
2220     noconfigdirs="$noconfigdirs sim target-rda"
2221     ;;
2222   *-*-darwin*)
2223     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2224     noconfigdirs="$noconfigdirs sim target-rda"
2225     noconfigdirs="$noconfigdirs ${libgcj}"
2226     ;;
2227   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2228     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2229     ;;
2230   *-*-freebsd*)
2231     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2232     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2233         && test -f /usr/local/include/gmp.h; then
2234       with_gmp=/usr/local
2235     fi
2236
2237     # Skip some stuff that's unsupported on some FreeBSD configurations.
2238     case "${target}" in
2239       i*86-*-*) ;;
2240       alpha*-*-*) ;;
2241       *)
2242         noconfigdirs="$noconfigdirs ${libgcj}"
2243         ;;
2244     esac
2245     ;;
2246   *-*-kaos*)
2247     # Remove unsupported stuff on all kaOS configurations.
2248     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2249     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2250     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2251     noconfigdirs="$noconfigdirs target-libgloss"
2252     ;;
2253   *-*-netbsd*)
2254     # Skip some stuff on all NetBSD configurations.
2255     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2256
2257     # Skip some stuff that's unsupported on some NetBSD configurations.
2258     case "${target}" in
2259       i*86-*-netbsdelf*) ;;
2260       arm*-*-netbsdelf*) ;;
2261       *)
2262         noconfigdirs="$noconfigdirs ${libgcj}"
2263         ;;
2264     esac
2265     ;;
2266   *-*-netware*)
2267     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2268     ;;
2269   *-*-rtems*)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272     # The tpf target doesn't support gdb yet.
2273   *-*-tpf*)
2274     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2275     ;;
2276   *-*-uclinux*)
2277     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2278     ;;
2279   *-*-vxworks*)
2280     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2281     ;;
2282   alpha*-dec-osf*)
2283     # ld works, but does not support shared libraries.
2284     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2285     # gas doesn't generate exception information.
2286     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2287     ;;
2288   alpha*-*-*vms*)
2289     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2290     ;;
2291   alpha*-*-linux*)
2292     # newlib is not 64 bit ready
2293     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2294     ;;
2295   alpha*-*-*)
2296     # newlib is not 64 bit ready
2297     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2298     ;;
2299   am33_2.0-*-linux*)
2300     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2301     ;;
2302   sh-*-linux*)
2303     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2304     ;;
2305   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2306     noconfigdirs="$noconfigdirs ${libgcj}"
2307     noconfigdirs="$noconfigdirs target-examples"
2308     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2309     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2310     noconfigdirs="$noconfigdirs expect dejagnu"
2311     # the C++ libraries don't build on top of CE's C libraries
2312     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2313     noconfigdirs="$noconfigdirs target-newlib"
2314     case "${host}" in
2315       *-*-cygwin*) ;; # keep gdb and readline
2316       *) noconfigdirs="$noconfigdirs gdb readline"
2317          ;;
2318     esac
2319     libgloss_dir=wince
2320     ;;
2321   arc-*-*)
2322     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2323     ;;
2324   arm-semi-aof )
2325     ;;
2326   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2327     noconfigdirs="$noconfigdirs ${libgcj}"
2328     libgloss_dir=arm
2329     ;;
2330   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2331     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2332     libgloss_dir=arm
2333     ;;
2334   arm*-*-linux-gnueabi)
2335     noconfigdirs="$noconfigdirs target-qthreads"
2336     case ${with_newlib} in
2337       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2338     esac
2339     libgloss_dir=arm
2340     ;;
2341   arm*-*-symbianelf*)
2342     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2343     libgloss_dir=arm
2344     ;;
2345   arm-*-pe*)
2346     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2347     ;;
2348   thumb-*-coff)
2349     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2350     ;;
2351   thumb-*-elf)
2352     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2353     ;;
2354   thumb-*-pe)
2355     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2356     ;;
2357   arm-*-riscix*)
2358     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2359     ;;
2360   avr-*-*)
2361     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2362     ;;
2363   bfin-*-*)
2364     noconfigdirs="$noconfigdirs gdb"
2365     if test x${is_cross_compiler} != xno ; then
2366       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2367     fi
2368     ;;
2369   c4x-*-* | tic4x-*-*)
2370     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2371     ;;
2372   c54x*-*-* | tic54x-*-*)
2373     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2374     ;;
2375   cr16-*-*)
2376     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2377     ;;
2378   cris-*-* | crisv32-*-*)
2379     unsupported_languages="$unsupported_languages java"
2380     case "${target}" in
2381       *-*-aout)
2382         unsupported_languages="$unsupported_languages fortran"
2383         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2384       *-*-elf)
2385         noconfigdirs="$noconfigdirs target-boehm-gc";;
2386       *-*-linux*)
2387         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2388       *)
2389         unsupported_languages="$unsupported_languages fortran"
2390         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2391     esac
2392     libgloss_dir=cris
2393     ;;
2394   crx-*-*)
2395     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2396     ;;
2397   d10v-*-*)
2398     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2399     ;;
2400   d30v-*-*)
2401     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2402     ;;
2403   ep9312-*-elf | ep9312-*-coff)
2404     libgloss_dir=arm
2405     ;;
2406   fr30-*-elf*)
2407     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2408     ;;
2409   frv-*-*)
2410     noconfigdirs="$noconfigdirs ${libgcj}"
2411     ;;
2412   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   extra_mpfr_configure_flags='--with-gmp-build=$$r/$(HOST_SUBDIR)/gmp'
4604   # Do not test the gmp version.  Assume that it is sufficient, since
4605   # it is in the source tree, and the library has not been built yet
4606   # but it would be included on the link line in the version check below
4607   # hence making the test fail.
4608   have_gmp=yes
4609 fi
4610
4611 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4612   have_gmp=yes
4613   saved_CFLAGS="$CFLAGS"
4614   CFLAGS="$CFLAGS $gmpinc"
4615   # Check GMP actually works
4616   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4617 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4618
4619 cat >conftest.$ac_ext <<_ACEOF
4620 /* confdefs.h.  */
4621 _ACEOF
4622 cat confdefs.h >>conftest.$ac_ext
4623 cat >>conftest.$ac_ext <<_ACEOF
4624 /* end confdefs.h.  */
4625 #include "gmp.h"
4626 int
4627 main ()
4628 {
4629
4630   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 2)
4631   choke me
4632   #endif
4633
4634   ;
4635   return 0;
4636 }
4637 _ACEOF
4638 rm -f conftest.$ac_objext
4639 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4640   (eval $ac_compile) 2>conftest.er1
4641   ac_status=$?
4642   grep -v '^ *+' conftest.er1 >conftest.err
4643   rm -f conftest.er1
4644   cat conftest.err >&5
4645   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4646   (exit $ac_status); } &&
4647          { ac_try='test -z "$ac_c_werror_flag"
4648                          || test ! -s conftest.err'
4649   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4650   (eval $ac_try) 2>&5
4651   ac_status=$?
4652   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4653   (exit $ac_status); }; } &&
4654          { ac_try='test -s conftest.$ac_objext'
4655   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4656   (eval $ac_try) 2>&5
4657   ac_status=$?
4658   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4659   (exit $ac_status); }; }; then
4660   echo "$as_me:$LINENO: result: yes" >&5
4661 echo "${ECHO_T}yes" >&6
4662 else
4663   echo "$as_me: failed program was:" >&5
4664 sed 's/^/| /' conftest.$ac_ext >&5
4665
4666 echo "$as_me:$LINENO: result: no" >&5
4667 echo "${ECHO_T}no" >&6; have_gmp=no
4668 fi
4669 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4670
4671   if test x"$have_gmp" = xyes; then
4672     saved_LIBS="$LIBS"
4673     LIBS="$LIBS $gmplibs"
4674         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4675 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4676     cat >conftest.$ac_ext <<_ACEOF
4677 /* confdefs.h.  */
4678 _ACEOF
4679 cat confdefs.h >>conftest.$ac_ext
4680 cat >>conftest.$ac_ext <<_ACEOF
4681 /* end confdefs.h.  */
4682 #include <gmp.h>
4683     #include <mpfr.h>
4684 int
4685 main ()
4686 {
4687
4688     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,1)
4689     choke me
4690     #endif
4691     mpfr_t n;
4692     mpfr_t x;
4693     int t;
4694     mpfr_init (n);
4695     mpfr_init (x);
4696     mpfr_atan2 (n, n, x, GMP_RNDN);
4697     mpfr_erfc (n, x, GMP_RNDN);
4698     mpfr_subnormalize (x, t, GMP_RNDN);
4699
4700   ;
4701   return 0;
4702 }
4703 _ACEOF
4704 rm -f conftest.$ac_objext conftest$ac_exeext
4705 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4706   (eval $ac_link) 2>conftest.er1
4707   ac_status=$?
4708   grep -v '^ *+' conftest.er1 >conftest.err
4709   rm -f conftest.er1
4710   cat conftest.err >&5
4711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4712   (exit $ac_status); } &&
4713          { ac_try='test -z "$ac_c_werror_flag"
4714                          || test ! -s conftest.err'
4715   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4716   (eval $ac_try) 2>&5
4717   ac_status=$?
4718   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4719   (exit $ac_status); }; } &&
4720          { ac_try='test -s conftest$ac_exeext'
4721   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4722   (eval $ac_try) 2>&5
4723   ac_status=$?
4724   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4725   (exit $ac_status); }; }; then
4726   cat >conftest.$ac_ext <<_ACEOF
4727 /* confdefs.h.  */
4728 _ACEOF
4729 cat confdefs.h >>conftest.$ac_ext
4730 cat >>conftest.$ac_ext <<_ACEOF
4731 /* end confdefs.h.  */
4732 #include <gmp.h>
4733     #include <mpfr.h>
4734 int
4735 main ()
4736 {
4737
4738     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4739     choke me
4740     #endif
4741     mpfr_t n; mpfr_init(n);
4742
4743   ;
4744   return 0;
4745 }
4746 _ACEOF
4747 rm -f conftest.$ac_objext conftest$ac_exeext
4748 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4749   (eval $ac_link) 2>conftest.er1
4750   ac_status=$?
4751   grep -v '^ *+' conftest.er1 >conftest.err
4752   rm -f conftest.er1
4753   cat conftest.err >&5
4754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4755   (exit $ac_status); } &&
4756          { ac_try='test -z "$ac_c_werror_flag"
4757                          || test ! -s conftest.err'
4758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4759   (eval $ac_try) 2>&5
4760   ac_status=$?
4761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4762   (exit $ac_status); }; } &&
4763          { ac_try='test -s conftest$ac_exeext'
4764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4765   (eval $ac_try) 2>&5
4766   ac_status=$?
4767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4768   (exit $ac_status); }; }; then
4769   echo "$as_me:$LINENO: result: yes" >&5
4770 echo "${ECHO_T}yes" >&6
4771 else
4772   echo "$as_me: failed program was:" >&5
4773 sed 's/^/| /' conftest.$ac_ext >&5
4774
4775 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4776 echo "${ECHO_T}buggy but acceptable" >&6
4777 fi
4778 rm -f conftest.err conftest.$ac_objext \
4779       conftest$ac_exeext conftest.$ac_ext
4780 else
4781   echo "$as_me: failed program was:" >&5
4782 sed 's/^/| /' conftest.$ac_ext >&5
4783
4784 echo "$as_me:$LINENO: result: no" >&5
4785 echo "${ECHO_T}no" >&6; have_gmp=no
4786 fi
4787 rm -f conftest.err conftest.$ac_objext \
4788       conftest$ac_exeext conftest.$ac_ext
4789       LIBS="$saved_LIBS"
4790   fi
4791   CFLAGS="$saved_CFLAGS"
4792
4793   if test x$have_gmp != xyes; then
4794     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4795 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4796 Copies of these libraries' source code can be found at their respective
4797 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4798 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4799 If you obtained GMP and/or MPFR from a vendor distribution package, make
4800 sure that you have installed both the libraries and the header files.
4801 They may be located in separate packages." >&5
4802 echo "$as_me: error: Building GCC requires GMP 4.2+ and MPFR 2.3.2+.
4803 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4804 Copies of these libraries' source code can be found at their respective
4805 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4806 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4807 If you obtained GMP and/or MPFR from a vendor distribution package, make
4808 sure that you have installed both the libraries and the header files.
4809 They may be located in separate packages." >&2;}
4810    { (exit 1); exit 1; }; }
4811   fi
4812 fi
4813
4814 # Flags needed for both GMP and/or MPFR
4815
4816
4817
4818
4819 # Allow host libstdc++ to be specified for static linking with PPL.
4820
4821 # Check whether --with-host-libstdcxx or --without-host-libstdcxx was given.
4822 if test "${with_host_libstdcxx+set}" = set; then
4823   withval="$with_host_libstdcxx"
4824
4825 fi;
4826
4827 case $with_host_libstdcxx in
4828   no|yes)
4829     { { echo "$as_me:$LINENO: error: -with-host-libstdcxx needs an argument" >&5
4830 echo "$as_me: error: -with-host-libstdcxx needs an argument" >&2;}
4831    { (exit 1); exit 1; }; }
4832     ;;
4833 esac
4834
4835 # Check for PPL
4836 ppl_major_version=0
4837 ppl_minor_version=10
4838 ppllibs=" -lppl_c -lppl -lgmpxx $with_host_libstdcxx "
4839 pplinc=
4840
4841
4842 # Check whether --with-ppl or --without-ppl was given.
4843 if test "${with_ppl+set}" = set; then
4844   withval="$with_ppl"
4845
4846 fi;
4847
4848 # Check whether --with-ppl_include or --without-ppl_include was given.
4849 if test "${with_ppl_include+set}" = set; then
4850   withval="$with_ppl_include"
4851
4852 fi;
4853
4854 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4855 if test "${with_ppl_lib+set}" = set; then
4856   withval="$with_ppl_lib"
4857
4858 fi;
4859
4860 case $with_ppl in
4861   no)
4862     ppllibs=
4863     ;;
4864   *)
4865     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4866     pplinc="-I$with_ppl/include $pplinc"
4867     LIBS="$ppllibs $LIBS"
4868     ;;
4869 esac
4870 if test "x$with_ppl_include" != x; then
4871   pplinc="-I$with_ppl_include $pplinc"
4872 fi
4873 if test "x$with_ppl_lib" != x; then
4874   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx $with_host_libstdcxx"
4875   LIBS="$ppllibs $LIBS"
4876 fi
4877 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4878   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '"$with_host_libstdcxx "
4879   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4880   LIBS="$ppllibs $LIBS"
4881 fi
4882
4883 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4884 if test "${enable_ppl_version_check+set}" = set; then
4885   enableval="$enable_ppl_version_check"
4886   ENABLE_PPL_CHECK=$enableval
4887 else
4888   ENABLE_PPL_CHECK=yes
4889 fi;
4890
4891 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4892   saved_CFLAGS="$CFLAGS"
4893   CFLAGS="$CFLAGS $pplinc $gmpinc"
4894   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4895 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4896   cat >conftest.$ac_ext <<_ACEOF
4897 /* confdefs.h.  */
4898 _ACEOF
4899 cat confdefs.h >>conftest.$ac_ext
4900 cat >>conftest.$ac_ext <<_ACEOF
4901 /* end confdefs.h.  */
4902 #include "ppl_c.h"
4903 int
4904 main ()
4905 {
4906
4907   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4908   choke me
4909   #endif
4910
4911   ;
4912   return 0;
4913 }
4914 _ACEOF
4915 rm -f conftest.$ac_objext
4916 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4917   (eval $ac_compile) 2>conftest.er1
4918   ac_status=$?
4919   grep -v '^ *+' conftest.er1 >conftest.err
4920   rm -f conftest.er1
4921   cat conftest.err >&5
4922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4923   (exit $ac_status); } &&
4924          { ac_try='test -z "$ac_c_werror_flag"
4925                          || test ! -s conftest.err'
4926   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4927   (eval $ac_try) 2>&5
4928   ac_status=$?
4929   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4930   (exit $ac_status); }; } &&
4931          { ac_try='test -s conftest.$ac_objext'
4932   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4933   (eval $ac_try) 2>&5
4934   ac_status=$?
4935   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4936   (exit $ac_status); }; }; then
4937   echo "$as_me:$LINENO: result: yes" >&5
4938 echo "${ECHO_T}yes" >&6
4939 else
4940   echo "$as_me: failed program was:" >&5
4941 sed 's/^/| /' conftest.$ac_ext >&5
4942
4943 echo "$as_me:$LINENO: result: no" >&5
4944 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4945 fi
4946 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4947   CFLAGS="$saved_CFLAGS"
4948 fi
4949
4950 # Flags needed for PPL
4951
4952
4953
4954
4955 # Check for CLOOG
4956 clooglibs=" -lcloog "
4957 clooginc=" -DCLOOG_PPL_BACKEND "
4958
4959
4960 # Check whether --with-cloog or --without-cloog was given.
4961 if test "${with_cloog+set}" = set; then
4962   withval="$with_cloog"
4963
4964 fi;
4965
4966 # Check whether --with-cloog_include or --without-cloog_include was given.
4967 if test "${with_cloog_include+set}" = set; then
4968   withval="$with_cloog_include"
4969
4970 fi;
4971
4972 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4973 if test "${with_cloog_lib+set}" = set; then
4974   withval="$with_cloog_lib"
4975
4976 fi;
4977
4978 case $with_cloog in
4979   no)
4980     clooglibs=
4981     clooginc=
4982     ;;
4983   *)
4984     clooglibs="-L$with_cloog/lib -lcloog"
4985     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4986     LIBS="$clooglibs $LIBS"
4987     ;;
4988 esac
4989 if test "x$with_cloog_include" != x; then
4990   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4991 fi
4992 if test "x$with_cloog_lib" != x; then
4993   clooglibs="-L$with_cloog_lib -lcloog"
4994   LIBS="$clooglibs $LIBS"
4995 fi
4996 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4997   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4998   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4999   LIBS="$clooglibs $LIBS"
5000 fi
5001
5002 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
5003 if test "${enable_cloog_version_check+set}" = set; then
5004   enableval="$enable_cloog_version_check"
5005   ENABLE_CLOOG_CHECK=$enableval
5006 else
5007   ENABLE_CLOOG_CHECK=yes
5008 fi;
5009
5010 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
5011   saved_CFLAGS="$CFLAGS"
5012   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
5013   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
5014 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
5015   cat >conftest.$ac_ext <<_ACEOF
5016 /* confdefs.h.  */
5017 _ACEOF
5018 cat confdefs.h >>conftest.$ac_ext
5019 cat >>conftest.$ac_ext <<_ACEOF
5020 /* end confdefs.h.  */
5021 #include "cloog/cloog.h"
5022 int
5023 main ()
5024 {
5025
5026   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5027   choke me
5028   #endif
5029
5030   ;
5031   return 0;
5032 }
5033 _ACEOF
5034 rm -f conftest.$ac_objext
5035 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5036   (eval $ac_compile) 2>conftest.er1
5037   ac_status=$?
5038   grep -v '^ *+' conftest.er1 >conftest.err
5039   rm -f conftest.er1
5040   cat conftest.err >&5
5041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5042   (exit $ac_status); } &&
5043          { ac_try='test -z "$ac_c_werror_flag"
5044                          || test ! -s conftest.err'
5045   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5046   (eval $ac_try) 2>&5
5047   ac_status=$?
5048   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5049   (exit $ac_status); }; } &&
5050          { ac_try='test -s conftest.$ac_objext'
5051   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5052   (eval $ac_try) 2>&5
5053   ac_status=$?
5054   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5055   (exit $ac_status); }; }; then
5056   echo "$as_me:$LINENO: result: yes" >&5
5057 echo "${ECHO_T}yes" >&6
5058 else
5059   echo "$as_me: failed program was:" >&5
5060 sed 's/^/| /' conftest.$ac_ext >&5
5061
5062 echo "$as_me:$LINENO: result: no" >&5
5063 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5064 fi
5065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5066   CFLAGS="$saved_CFLAGS"
5067 fi
5068
5069 # Flags needed for CLOOG
5070
5071
5072
5073
5074 # By default, C is the only stage 1 language.
5075 stage1_languages=,c,
5076
5077 # Figure out what language subdirectories are present.
5078 # Look if the user specified --enable-languages="..."; if not, use
5079 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5080 # go away some day.
5081 # NB:  embedded tabs in this IF block -- do not untabify
5082 if test -d ${srcdir}/gcc; then
5083   if test x"${enable_languages+set}" != xset; then
5084     if test x"${LANGUAGES+set}" = xset; then
5085       enable_languages="${LANGUAGES}"
5086         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5087     else
5088       enable_languages=all
5089     fi
5090   else
5091     if test x"${enable_languages}" = x ||
5092        test x"${enable_languages}" = xyes;
5093        then
5094       echo configure.in: --enable-languages needs at least one language argument 1>&2
5095       exit 1
5096     fi
5097   fi
5098   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5099
5100   # 'f95' is the old name for the 'fortran' language. We issue a warning
5101   # and make the substitution.
5102   case ,${enable_languages}, in
5103     *,f95,*)
5104       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5105       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5106       ;;
5107   esac
5108
5109   # First scan to see if an enabled language requires some other language.
5110   # We assume that a given config-lang.in will list all the language
5111   # front ends it requires, even if some are required indirectly.
5112   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5113     case ${lang_frag} in
5114       ..) ;;
5115       # The odd quoting in the next line works around
5116       # an apparent bug in bash 1.12 on linux.
5117       ${srcdir}/gcc/[*]/config-lang.in) ;;
5118       *)
5119         # From the config-lang.in, get $language, $lang_requires
5120         language=
5121         lang_requires=
5122         . ${lang_frag}
5123         for other in ${lang_requires} ; do
5124           case ,${enable_languages}, in
5125             *,$other,*) ;;
5126             *,all,*) ;;
5127             *,$language,*)
5128               echo " \`$other' language required by \`$language'; enabling" 1>&2
5129               enable_languages="${enable_languages},${other}"
5130               ;;
5131           esac
5132         done
5133         ;;
5134     esac
5135   done
5136
5137   new_enable_languages=,c,
5138   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5139   potential_languages=,c,
5140
5141   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5142     case ${lang_frag} in
5143       ..) ;;
5144       # The odd quoting in the next line works around
5145       # an apparent bug in bash 1.12 on linux.
5146       ${srcdir}/gcc/[*]/config-lang.in) ;;
5147       *)
5148         # From the config-lang.in, get $language, $target_libs,
5149         # $lang_dirs, $boot_language, and $build_by_default
5150         language=
5151         target_libs=
5152         lang_dirs=
5153         subdir_requires=
5154         boot_language=no
5155         build_by_default=yes
5156         . ${lang_frag}
5157         if test x${language} = x; then
5158           echo "${lang_frag} doesn't set \$language." 1>&2
5159           exit 1
5160         fi
5161
5162         case ,${enable_languages}, in
5163           *,${language},*)
5164             # Language was explicitly selected; include it.
5165             add_this_lang=yes
5166             ;;
5167           *,all,*)
5168             # 'all' was selected, select it if it is a default language
5169             add_this_lang=${build_by_default}
5170             ;;
5171           *)
5172             add_this_lang=no
5173             ;;
5174         esac
5175
5176         # Disable languages that need other directories if these aren't available.
5177         for i in $subdir_requires; do
5178           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5179           case ,${enable_languages}, in
5180             *,${language},*)
5181               # Specifically requested language; tell them.
5182               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5183 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5184    { (exit 1); exit 1; }; }
5185               ;;
5186             *)
5187               # Silently disable.
5188               add_this_lang=unsupported
5189               ;;
5190           esac
5191         done
5192
5193         # Disable Ada if no preexisting GNAT is available.
5194         case ,${enable_languages},:${language}:${have_gnat} in
5195           *,${language},*:ada:no)
5196             # Specifically requested language; tell them.
5197             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5198 echo "$as_me: error: GNAT is required to build $language" >&2;}
5199    { (exit 1); exit 1; }; }
5200             ;;
5201           *:ada:no)
5202             # Silently disable.
5203             add_this_lang=unsupported
5204             ;;
5205         esac
5206
5207         # Disable a language that is unsupported by the target.
5208         case " $unsupported_languages " in
5209           *" $language "*)
5210             add_this_lang=unsupported
5211             ;;
5212         esac
5213
5214         case $add_this_lang in
5215           unsupported)
5216             # Remove language-dependent dirs.
5217             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5218             ;;
5219           no)
5220             # Remove language-dependent dirs; still show language as supported.
5221             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5222             potential_languages="${potential_languages}${language},"
5223             ;;
5224           yes)
5225             new_enable_languages="${new_enable_languages}${language},"
5226             potential_languages="${potential_languages}${language},"
5227             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5228             case ${boot_language} in
5229               yes)
5230                 # Add to (comma-separated) list of stage 1 languages.
5231                 stage1_languages="${stage1_languages}${language},"
5232                 ;;
5233             esac
5234             ;;
5235         esac
5236         ;;
5237     esac
5238   done
5239
5240   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5241 if test "${enable_stage1_languages+set}" = set; then
5242   enableval="$enable_stage1_languages"
5243   case ,${enable_stage1_languages}, in
5244     ,no,|,,)
5245       # Set it to something that will have no effect in the loop below
5246       enable_stage1_languages=c ;;
5247     ,yes,)
5248       enable_stage1_languages=`echo $new_enable_languages | \
5249         sed -e "s/^,//" -e "s/,$//" ` ;;
5250     *,all,*)
5251       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5252         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5253   esac
5254
5255   # Add "good" languages from enable_stage1_languages to stage1_languages,
5256   # while "bad" languages go in missing_languages.  Leave no duplicates.
5257   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5258     case $potential_languages in
5259       *,$i,*)
5260         case $stage1_languages in
5261           *,$i,*) ;;
5262           *) stage1_languages="$stage1_languages$i," ;;
5263         esac ;;
5264       *)
5265         case $missing_languages in
5266           *,$i,*) ;;
5267           *) missing_languages="$missing_languages$i," ;;
5268         esac ;;
5269      esac
5270   done
5271 fi;
5272
5273   # Remove leading/trailing commas that were added for simplicity
5274   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5275   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5276   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5277   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5278
5279   if test "x$missing_languages" != x; then
5280     { { echo "$as_me:$LINENO: error:
5281 The following requested languages could not be built: ${missing_languages}
5282 Supported languages are: ${potential_languages}" >&5
5283 echo "$as_me: error:
5284 The following requested languages could not be built: ${missing_languages}
5285 Supported languages are: ${potential_languages}" >&2;}
5286    { (exit 1); exit 1; }; }
5287   fi
5288   if test "x$new_enable_languages" != "x$enable_languages"; then
5289     echo The following languages will be built: ${new_enable_languages}
5290     enable_languages="$new_enable_languages"
5291   fi
5292
5293
5294   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5295 fi
5296
5297 # Handle --disable-<component> generically.
5298 for dir in $configdirs $build_configdirs $target_configdirs ; do
5299   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5300   varname=`echo $dirname | sed -e s/+/_/g`
5301   if eval test x\${enable_${varname}} "=" xno ; then
5302     noconfigdirs="$noconfigdirs $dir"
5303   fi
5304 done
5305
5306 # Check for Boehm's garbage collector
5307 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5308 if test "${enable_objc_gc+set}" = set; then
5309   enableval="$enable_objc_gc"
5310   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5311   *,objc,*:*:yes:*target-boehm-gc*)
5312     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5313 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5314    { (exit 1); exit 1; }; }
5315     ;;
5316 esac
5317 fi;
5318
5319 # Make sure we only build Boehm's garbage collector if required.
5320 case ,${enable_languages},:${enable_objc_gc} in
5321   *,objc,*:yes)
5322     # Keep target-boehm-gc if requested for Objective-C.
5323     ;;
5324   *)
5325     # Otherwise remove target-boehm-gc depending on target-libjava.
5326     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5327       noconfigdirs="$noconfigdirs target-boehm-gc"
5328     fi
5329     ;;
5330 esac
5331
5332 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5333 # $build_configdirs and $target_configdirs.
5334 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5335
5336 notsupp=""
5337 for dir in . $skipdirs $noconfigdirs ; do
5338   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5339   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5340     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5341     if test -r $srcdir/$dirname/configure ; then
5342       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5343         true
5344       else
5345         notsupp="$notsupp $dir"
5346       fi
5347     fi
5348   fi
5349   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5350     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5351     if test -r $srcdir/$dirname/configure ; then
5352       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5353         true
5354       else
5355         notsupp="$notsupp $dir"
5356       fi
5357     fi
5358   fi
5359   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5360     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5361     if test -r $srcdir/$dirname/configure ; then
5362       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5363         true
5364       else
5365         notsupp="$notsupp $dir"
5366       fi
5367     fi
5368   fi
5369 done
5370
5371 # Sometimes the tools are distributed with libiberty but with no other
5372 # libraries.  In that case, we don't want to build target-libiberty.
5373 # Don't let libgcc imply libiberty either.
5374 if test -n "${target_configdirs}" ; then
5375   libgcc=
5376   others=
5377   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5378     if test "$i" = "libgcc"; then
5379       libgcc=target-libgcc
5380     elif test "$i" != "libiberty" ; then
5381       if test -r $srcdir/$i/configure ; then
5382         others=yes;
5383         break;
5384       fi
5385     fi
5386   done
5387   if test -z "${others}" ; then
5388     target_configdirs=$libgcc
5389   fi
5390 fi
5391
5392 # Quietly strip out all directories which aren't configurable in this tree.
5393 # This relies on all configurable subdirectories being autoconfiscated, which
5394 # is now the case.
5395 build_configdirs_all="$build_configdirs"
5396 build_configdirs=
5397 for i in ${build_configdirs_all} ; do
5398   j=`echo $i | sed -e s/build-//g`
5399   if test -f ${srcdir}/$j/configure ; then
5400     build_configdirs="${build_configdirs} $i"
5401   fi
5402 done
5403
5404 configdirs_all="$configdirs"
5405 configdirs=
5406 for i in ${configdirs_all} ; do
5407   if test -f ${srcdir}/$i/configure ; then
5408     configdirs="${configdirs} $i"
5409   fi
5410 done
5411
5412 target_configdirs_all="$target_configdirs"
5413 target_configdirs=
5414 for i in ${target_configdirs_all} ; do
5415   j=`echo $i | sed -e s/target-//g`
5416   if test -f ${srcdir}/$j/configure ; then
5417     target_configdirs="${target_configdirs} $i"
5418   fi
5419 done
5420
5421 # Produce a warning message for the subdirs we can't configure.
5422 # This isn't especially interesting in the Cygnus tree, but in the individual
5423 # FSF releases, it's important to let people know when their machine isn't
5424 # supported by the one or two programs in a package.
5425
5426 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5427   # If $appdirs is non-empty, at least one of those directories must still
5428   # be configured, or we error out.  (E.g., if the gas release supports a
5429   # specified target in some subdirs but not the gas subdir, we shouldn't
5430   # pretend that all is well.)
5431   if test -n "$appdirs" ; then
5432     for dir in $appdirs ; do
5433       if test -r $dir/Makefile.in ; then
5434         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5435           appdirs=""
5436           break
5437         fi
5438         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5439           appdirs=""
5440           break
5441         fi
5442       fi
5443     done
5444     if test -n "$appdirs" ; then
5445       echo "*** This configuration is not supported by this package." 1>&2
5446       exit 1
5447     fi
5448   fi
5449   # Okay, some application will build, or we don't care to check.  Still
5450   # notify of subdirs not getting built.
5451   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5452   echo "    ${notsupp}" 1>&2
5453   echo "    (Any other directories should still work fine.)" 1>&2
5454 fi
5455
5456 case "$host" in
5457   *msdosdjgpp*)
5458     enable_gdbtk=no ;;
5459 esac
5460
5461 # To find our prefix, in gcc_cv_tool_prefix.
5462
5463 # The user is always right.
5464 if test "${PATH_SEPARATOR+set}" != set; then
5465   echo "#! /bin/sh" >conf$$.sh
5466   echo  "exit 0"   >>conf$$.sh
5467   chmod +x conf$$.sh
5468   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5469     PATH_SEPARATOR=';'
5470   else
5471     PATH_SEPARATOR=:
5472   fi
5473   rm -f conf$$.sh
5474 fi
5475
5476
5477
5478 if test "x$exec_prefix" = xNONE; then
5479         if test "x$prefix" = xNONE; then
5480                 gcc_cv_tool_prefix=$ac_default_prefix
5481         else
5482                 gcc_cv_tool_prefix=$prefix
5483         fi
5484 else
5485         gcc_cv_tool_prefix=$exec_prefix
5486 fi
5487
5488 # If there is no compiler in the tree, use the PATH only.  In any
5489 # case, if there is no compiler in the tree nobody should use
5490 # AS_FOR_TARGET and LD_FOR_TARGET.
5491 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5492     gcc_version=`cat $srcdir/gcc/BASE-VER`
5493     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5494     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5495     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5496     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5497     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5498     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5499 else
5500     gcc_cv_tool_dirs=
5501 fi
5502
5503 if test x$build = x$target && test -n "$md_exec_prefix"; then
5504         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5505 fi
5506
5507
5508
5509 copy_dirs=
5510
5511
5512 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5513 if test "${with_build_sysroot+set}" = set; then
5514   withval="$with_build_sysroot"
5515   if test x"$withval" != x ; then
5516      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5517    fi
5518 else
5519   SYSROOT_CFLAGS_FOR_TARGET=
5520 fi;
5521
5522
5523
5524 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5525 if test "${with_debug_prefix_map+set}" = set; then
5526   withval="$with_debug_prefix_map"
5527   if test x"$withval" != x; then
5528      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5529      for debug_map in $withval; do
5530        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5531      done
5532    fi
5533 else
5534   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5535 fi;
5536
5537
5538 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5539 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5540 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5541 # We want to ensure that TARGET libraries (which we know are built with
5542 # gcc) are built with "-O2 -g", so include those options when setting
5543 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5544 if test "x$CFLAGS_FOR_TARGET" = x; then
5545   CFLAGS_FOR_TARGET=$CFLAGS
5546   case " $CFLAGS " in
5547     *" -O2 "*) ;;
5548     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5549   esac
5550   case " $CFLAGS " in
5551     *" -g "* | *" -g3 "*) ;;
5552     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5553   esac
5554 fi
5555
5556
5557 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5558   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5559   case " $CXXFLAGS " in
5560     *" -O2 "*) ;;
5561     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5562   esac
5563   case " $CXXFLAGS " in
5564     *" -g "* | *" -g3 "*) ;;
5565     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5566   esac
5567 fi
5568
5569
5570 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5571 # the named directory are copied to $(tooldir)/sys-include.
5572 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5573   if test x${is_cross_compiler} = xno ; then
5574     echo 1>&2 '***' --with-headers is only supported when cross compiling
5575     exit 1
5576   fi
5577   if test x"${with_headers}" != xyes ; then
5578     x=${gcc_cv_tool_prefix}
5579     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5580   fi
5581 fi
5582
5583 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5584 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5585 # are permitted.
5586 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5587   if test x${is_cross_compiler} = xno ; then
5588     echo 1>&2 '***' --with-libs is only supported when cross compiling
5589     exit 1
5590   fi
5591   if test x"${with_libs}" != xyes ; then
5592     # Copy the libraries in reverse order, so that files in the first named
5593     # library override files in subsequent libraries.
5594     x=${gcc_cv_tool_prefix}
5595     for l in ${with_libs}; do
5596       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5597     done
5598   fi
5599 fi
5600
5601 # Set with_gnu_as and with_gnu_ld as appropriate.
5602 #
5603 # This is done by determining whether or not the appropriate directory
5604 # is available, and by checking whether or not specific configurations
5605 # have requested that this magic not happen.
5606 #
5607 # The command line options always override the explicit settings in
5608 # configure.in, and the settings in configure.in override this magic.
5609 #
5610 # If the default for a toolchain is to use GNU as and ld, and you don't
5611 # want to do that, then you should use the --without-gnu-as and
5612 # --without-gnu-ld options for the configure script.
5613
5614 if test x${use_gnu_as} = x &&
5615    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5616   with_gnu_as=yes
5617   extra_host_args="$extra_host_args --with-gnu-as"
5618 fi
5619
5620 if test x${use_gnu_ld} = x &&
5621    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5622   with_gnu_ld=yes
5623   extra_host_args="$extra_host_args --with-gnu-ld"
5624 fi
5625
5626 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5627 # can detect this case.
5628
5629 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5630   with_newlib=yes
5631   extra_host_args="$extra_host_args --with-newlib"
5632 fi
5633
5634 # Handle ${copy_dirs}
5635 set fnord ${copy_dirs}
5636 shift
5637 while test $# != 0 ; do
5638   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5639     :
5640   else
5641     echo Copying $1 to $2
5642
5643     # Use the install script to create the directory and all required
5644     # parent directories.
5645     if test -d $2 ; then
5646       :
5647     else
5648       echo >config.temp
5649       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5650     fi
5651
5652     # Copy the directory, assuming we have tar.
5653     # FIXME: Should we use B in the second tar?  Not all systems support it.
5654     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5655
5656     # It is the responsibility of the user to correctly adjust all
5657     # symlinks.  If somebody can figure out how to handle them correctly
5658     # here, feel free to add the code.
5659
5660     echo $1 > $2/COPIED
5661   fi
5662   shift; shift
5663 done
5664
5665 # Determine a target-dependent exec_prefix that the installed
5666 # gcc will search in.  Keep this list sorted by triplet, with
5667 # the *-*-osname triplets last.
5668 md_exec_prefix=
5669 case "${target}" in
5670   alpha*-*-*vms*)
5671     md_exec_prefix=/gnu/lib/gcc-lib
5672     ;;
5673   i[34567]86-pc-msdosdjgpp*)
5674     md_exec_prefix=/dev/env/DJDIR/bin
5675     ;;
5676   i[34567]86-*-sco3.2v5*)
5677     if test $with_gnu_as = yes; then
5678       md_exec_prefix=/usr/gnu/bin
5679     else
5680       md_exec_prefix=/usr/ccs/bin/elf
5681     fi
5682     ;;
5683
5684   mn10300-*-* | \
5685   powerpc-*-chorusos* | \
5686   powerpc*-*-eabi* | \
5687   powerpc*-*-sysv* | \
5688   powerpc*-*-kaos* | \
5689   s390x-ibm-tpf*)
5690     md_exec_prefix=/usr/ccs/bin
5691     ;;
5692   sparc64-*-elf*)
5693     ;;
5694   v850*-*-*)
5695     md_exec_prefix=/usr/ccs/bin
5696     ;;
5697   xtensa*-*-elf*)
5698     ;;
5699
5700   *-*-beos* | \
5701   *-*-elf* | \
5702   *-*-hpux* | \
5703   *-*-netware* | \
5704   *-*-nto-qnx* | \
5705   *-*-rtems* | \
5706   *-*-solaris2* | \
5707   *-*-sysv[45]* | \
5708   *-*-vxworks* | \
5709   *-wrs-windiss)
5710     md_exec_prefix=/usr/ccs/bin
5711     ;;
5712 esac
5713
5714 extra_arflags_for_target=
5715 extra_nmflags_for_target=
5716 extra_ranlibflags_for_target=
5717 target_makefile_frag=/dev/null
5718 case "${target}" in
5719   mep*-*-*)
5720     target_makefile_frag="config/mt-mep"
5721     ;;
5722   spu-*-*)
5723     target_makefile_frag="config/mt-spu"
5724     ;;
5725   mips*-sde-elf*)
5726     target_makefile_frag="config/mt-sde"
5727     ;;
5728   mipsisa*-*-elfoabi*)
5729     target_makefile_frag="config/mt-mips-elfoabi"
5730     ;;
5731   mips*-*-*linux* | mips*-*-gnu*)
5732     target_makefile_frag="config/mt-mips-gnu"
5733     ;;
5734   *-*-netware*)
5735     target_makefile_frag="config/mt-netware"
5736     ;;
5737   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5738     target_makefile_frag="config/mt-gnu"
5739     ;;
5740   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5741     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5742     # commands to handle both 32-bit and 64-bit objects.  These flags are
5743     # harmless if we're using GNU nm or ar.
5744     extra_arflags_for_target=" -X32_64"
5745     extra_nmflags_for_target=" -B -X32_64"
5746     ;;
5747   *-*-darwin*)
5748     # ranlib from Darwin requires the -c flag to look at common symbols.
5749     extra_ranlibflags_for_target=" -c"
5750     ;;
5751   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5752     target_makefile_frag="config/mt-wince"
5753     ;;
5754 esac
5755
5756 alphaieee_frag=/dev/null
5757 case $target in
5758   alpha*-*-*)
5759     # This just makes sure to use the -mieee option to build target libs.
5760     # This should probably be set individually by each library.
5761     alphaieee_frag="config/mt-alphaieee"
5762     ;;
5763 esac
5764
5765 # If --enable-target-optspace always use -Os instead of -O2 to build
5766 # the target libraries, similarly if it is not specified, use -Os
5767 # on selected platforms.
5768 ospace_frag=/dev/null
5769 case "${enable_target_optspace}:${target}" in
5770   yes:*)
5771     ospace_frag="config/mt-ospace"
5772     ;;
5773   :d30v-*)
5774     ospace_frag="config/mt-d30v"
5775     ;;
5776   :m32r-* | :d10v-* | :fr30-*)
5777     ospace_frag="config/mt-ospace"
5778     ;;
5779   no:* | :*)
5780     ;;
5781   *)
5782     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5783     ;;
5784 esac
5785
5786 # Default to using --with-stabs for certain targets.
5787 if test x${with_stabs} = x ; then
5788   case "${target}" in
5789   mips*-*-irix[56]*)
5790     ;;
5791   mips*-*-* | alpha*-*-osf*)
5792     with_stabs=yes;
5793     extra_host_args="${extra_host_args} --with-stabs"
5794     ;;
5795   esac
5796 fi
5797
5798 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5799 # them automatically.
5800 case "${host}" in
5801   hppa*64*-*-hpux11*)
5802     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5803     ;;
5804 esac
5805
5806 # Some systems (e.g., one of the i386-aix systems the gas testers are
5807 # using) don't handle "\$" correctly, so don't use it here.
5808 tooldir='${exec_prefix}'/${target_noncanonical}
5809 build_tooldir=${tooldir}
5810
5811 # Create a .gdbinit file which runs the one in srcdir
5812 # and tells GDB to look there for source files.
5813
5814 if test -r ${srcdir}/.gdbinit ; then
5815   case ${srcdir} in
5816     .) ;;
5817     *) cat > ./.gdbinit <<EOF
5818 # ${NO_EDIT}
5819 dir ${srcdir}
5820 dir .
5821 source ${srcdir}/.gdbinit
5822 EOF
5823     ;;
5824   esac
5825 fi
5826
5827 # Make sure that the compiler is able to generate an executable.  If it
5828 # can't, we are probably in trouble.  We don't care whether we can run the
5829 # executable--we might be using a cross compiler--we only care whether it
5830 # can be created.  At this point the main configure script has set CC.
5831 we_are_ok=no
5832 echo "int main () { return 0; }" > conftest.c
5833 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5834 if test $? = 0 ; then
5835   if test -s conftest || test -s conftest.exe ; then
5836     we_are_ok=yes
5837   fi
5838 fi
5839 case $we_are_ok in
5840   no)
5841     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5842     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5843     rm -f conftest*
5844     exit 1
5845     ;;
5846 esac
5847 rm -f conftest*
5848
5849 # The Solaris /usr/ucb/cc compiler does not appear to work.
5850 case "${host}" in
5851   sparc-sun-solaris2*)
5852       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5853       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5854           could_use=
5855           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5856           if test -d /opt/cygnus/bin ; then
5857               if test "$could_use" = "" ; then
5858                   could_use="/opt/cygnus/bin"
5859               else
5860                   could_use="$could_use or /opt/cygnus/bin"
5861               fi
5862           fi
5863         if test "$could_use" = "" ; then
5864             echo "Warning: compilation may fail because you're using"
5865             echo "/usr/ucb/cc.  You should change your PATH or CC "
5866             echo "variable and rerun configure."
5867         else
5868             echo "Warning: compilation may fail because you're using"
5869             echo "/usr/ucb/cc, when you should use the C compiler from"
5870             echo "$could_use.  You should change your"
5871             echo "PATH or CC variable and rerun configure."
5872         fi
5873       fi
5874   ;;
5875 esac
5876
5877 # Decide which environment variable is used to find dynamic libraries.
5878 case "${host}" in
5879   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5880   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5881   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5882   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5883 esac
5884
5885 # On systems where the dynamic library environment variable is PATH,
5886 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5887 # built executables to PATH.
5888 if test "$RPATH_ENVVAR" = PATH; then
5889   GCC_SHLIB_SUBDIR=/shlib
5890 else
5891   GCC_SHLIB_SUBDIR=
5892 fi
5893
5894 # Record target_configdirs and the configure arguments for target and
5895 # build configuration in Makefile.
5896 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5897 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5898
5899 # Determine whether gdb needs tk/tcl or not.
5900 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5901 # and in that case we want gdb to be built without tk.  Ugh!
5902 # In fact I believe gdb is the *only* package directly dependent on tk,
5903 # so we should be able to put the 'maybe's in unconditionally and
5904 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5905 # 100% sure that that's safe though.
5906
5907 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5908 case "$enable_gdbtk" in
5909   no)
5910     GDB_TK="" ;;
5911   yes)
5912     GDB_TK="${gdb_tk}" ;;
5913   *)
5914     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5915     # distro.  Eventually someone will fix this and move Insight, nee
5916     # gdbtk to a separate directory.
5917     if test -d ${srcdir}/gdb/gdbtk ; then
5918       GDB_TK="${gdb_tk}"
5919     else
5920       GDB_TK=""
5921     fi
5922     ;;
5923 esac
5924 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5925 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5926
5927 # Strip out unwanted targets.
5928
5929 # While at that, we remove Makefiles if we were started for recursive
5930 # configuration, so that the top-level Makefile reconfigures them,
5931 # like we used to do when configure itself was recursive.
5932
5933 # Loop over modules.  $extrasub must be used with care, limiting as
5934 # much as possible the usage of range addresses.  That's because autoconf
5935 # splits the sed script to overcome limits in the number of commands,
5936 # and relying on carefully-timed sed passes may turn out to be very hard
5937 # to maintain later.  In this particular case, you just have to be careful
5938 # not to nest @if/@endif pairs, because configure will not warn you at all.
5939
5940 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5941 if test "${enable_bootstrap+set}" = set; then
5942   enableval="$enable_bootstrap"
5943
5944 else
5945   enable_bootstrap=default
5946 fi;
5947
5948 # Issue errors and warnings for invalid/strange bootstrap combinations.
5949 case "$configdirs" in
5950   *gcc*) have_compiler=yes ;;
5951   *) have_compiler=no ;;
5952 esac
5953
5954 case "$have_compiler:$host:$target:$enable_bootstrap" in
5955   *:*:*:no) ;;
5956
5957   # Default behavior.  Enable bootstrap if we have a compiler
5958   # and we are in a native configuration.
5959   yes:$build:$build:default)
5960     enable_bootstrap=yes ;;
5961
5962   *:*:*:default)
5963     enable_bootstrap=no ;;
5964
5965   # We have a compiler and we are in a native configuration, bootstrap is ok
5966   yes:$build:$build:yes)
5967     ;;
5968
5969   # Other configurations, but we have a compiler.  Assume the user knows
5970   # what he's doing.
5971   yes:*:*:yes)
5972     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5973 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5974     ;;
5975
5976   # No compiler: if they passed --enable-bootstrap explicitly, fail
5977   no:*:*:yes)
5978     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5979 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5980    { (exit 1); exit 1; }; } ;;
5981
5982   # Fail if wrong command line
5983   *)
5984     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5985 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5986    { (exit 1); exit 1; }; }
5987     ;;
5988 esac
5989
5990 # Adjust the toplevel makefile according to whether bootstrap was selected.
5991 case "$enable_bootstrap" in
5992   yes)
5993     bootstrap_suffix=bootstrap ;;
5994   no)
5995     bootstrap_suffix=no-bootstrap ;;
5996 esac
5997
5998 for module in ${build_configdirs} ; do
5999   if test -z "${no_recursion}" \
6000      && test -f ${build_subdir}/${module}/Makefile; then
6001     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
6002     rm -f ${build_subdir}/${module}/Makefile
6003   fi
6004   extrasub="$extrasub
6005 /^@if build-$module\$/d
6006 /^@endif build-$module\$/d
6007 /^@if build-$module-$bootstrap_suffix\$/d
6008 /^@endif build-$module-$bootstrap_suffix\$/d"
6009 done
6010 for module in ${configdirs} ; do
6011   if test -z "${no_recursion}"; then
6012     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
6013       if test -f ${file}; then
6014         echo 1>&2 "*** removing ${file} to force reconfigure"
6015         rm -f ${file}
6016       fi
6017     done
6018   fi
6019   extrasub="$extrasub
6020 /^@if $module\$/d
6021 /^@endif $module\$/d
6022 /^@if $module-$bootstrap_suffix\$/d
6023 /^@endif $module-$bootstrap_suffix\$/d"
6024 done
6025 for module in ${target_configdirs} ; do
6026   if test -z "${no_recursion}" \
6027      && test -f ${target_subdir}/${module}/Makefile; then
6028     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6029     rm -f ${target_subdir}/${module}/Makefile
6030   fi
6031   extrasub="$extrasub
6032 /^@if target-$module\$/d
6033 /^@endif target-$module\$/d
6034 /^@if target-$module-$bootstrap_suffix\$/d
6035 /^@endif target-$module-$bootstrap_suffix\$/d"
6036 done
6037
6038 extrasub="$extrasub
6039 /^@if /,/^@endif /d"
6040
6041 # Create the serialization dependencies.  This uses a temporary file.
6042
6043 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6044 if test "${enable_serial_configure+set}" = set; then
6045   enableval="$enable_serial_configure"
6046
6047 fi;
6048
6049 case ${enable_serial_configure} in
6050   yes)
6051     enable_serial_build_configure=yes
6052     enable_serial_host_configure=yes
6053     enable_serial_target_configure=yes
6054     ;;
6055 esac
6056
6057 # These force 'configure's to be done one at a time, to avoid problems
6058 # with contention over a shared config.cache.
6059 rm -f serdep.tmp
6060 echo '# serdep.tmp' > serdep.tmp
6061 olditem=
6062 test "x${enable_serial_build_configure}" = xyes &&
6063 for item in ${build_configdirs} ; do
6064   case ${olditem} in
6065     "") ;;
6066     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6067   esac
6068   olditem=${item}
6069 done
6070 olditem=
6071 test "x${enable_serial_host_configure}" = xyes &&
6072 for item in ${configdirs} ; do
6073   case ${olditem} in
6074     "") ;;
6075     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6076   esac
6077   olditem=${item}
6078 done
6079 olditem=
6080 test "x${enable_serial_target_configure}" = xyes &&
6081 for item in ${target_configdirs} ; do
6082   case ${olditem} in
6083     "") ;;
6084     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6085   esac
6086   olditem=${item}
6087 done
6088 serialization_dependencies=serdep.tmp
6089
6090
6091 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6092 # target, nonopt, and variable assignments.  These are the ones we
6093 # might not want to pass down to subconfigures.  Also strip
6094 # program-prefix, program-suffix, and program-transform-name, so that
6095 # we can pass down a consistent program-transform-name.
6096 baseargs=
6097 keep_next=no
6098 skip_next=no
6099 eval "set -- $ac_configure_args"
6100 for ac_arg
6101 do
6102   if test X"$skip_next" = X"yes"; then
6103     skip_next=no
6104     continue
6105   fi
6106   if test X"$keep_next" = X"yes"; then
6107     case $ac_arg in
6108       *\'*)
6109         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6110     esac
6111     baseargs="$baseargs '$ac_arg'"
6112     keep_next=no
6113     continue
6114   fi
6115
6116   # Handle separated arguments.  Based on the logic generated by
6117   # autoconf 2.59.
6118   case $ac_arg in
6119     *=* | --config-cache | -C | -disable-* | --disable-* \
6120       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6121       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6122       | -with-* | --with-* | -without-* | --without-* | --x)
6123       separate_arg=no
6124       ;;
6125     -*)
6126       separate_arg=yes
6127       ;;
6128     *)
6129       separate_arg=no
6130       ;;
6131   esac
6132
6133   case "$ac_arg" in
6134     --no*)
6135       continue
6136       ;;
6137     --c* | \
6138     --sr* | \
6139     --ho* | \
6140     --bu* | \
6141     --t* | \
6142     --program-* | \
6143     -cache_file* | \
6144     -srcdir* | \
6145     -host* | \
6146     -build* | \
6147     -target* | \
6148     -program-prefix* | \
6149     -program-suffix* | \
6150     -program-transform-name* )
6151       skip_next=$separate_arg
6152       continue
6153       ;;
6154     -*)
6155       # An option.  Add it.
6156       case $ac_arg in
6157         *\'*)
6158           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6159       esac
6160       baseargs="$baseargs '$ac_arg'"
6161       keep_next=$separate_arg
6162       ;;
6163     *)
6164       # Either a variable assignment, or a nonopt (triplet).  Don't
6165       # pass it down; let the Makefile handle this.
6166       continue
6167       ;;
6168   esac
6169 done
6170 # Remove the initial space we just introduced and, as these will be
6171 # expanded by make, quote '$'.
6172 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6173
6174 # Add in --program-transform-name, after --program-prefix and
6175 # --program-suffix have been applied to it.  Autoconf has already
6176 # doubled dollar signs and backslashes in program_transform_name; we want
6177 # the backslashes un-doubled, and then the entire thing wrapped in single
6178 # quotes, because this will be expanded first by make and then by the shell.
6179 # Also, because we want to override the logic in subdir configure scripts to
6180 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6181 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6182 ${program_transform_name}
6183 EOF_SED
6184 gcc_transform_name=`cat conftestsed.out`
6185 rm -f conftestsed.out
6186 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6187 if test "$silent" = yes; then
6188   baseargs="$baseargs --silent"
6189 fi
6190
6191 # For the build-side libraries, we just need to pretend we're native,
6192 # and not use the same cache file.  Multilibs are neither needed nor
6193 # desired.
6194 build_configargs="--cache-file=../config.cache ${baseargs}"
6195
6196 # For host modules, accept cache file option, or specification as blank.
6197 case "${cache_file}" in
6198 "") # empty
6199   cache_file_option="" ;;
6200 /* | [A-Za-z]:[\\/]* ) # absolute path
6201   cache_file_option="--cache-file=${cache_file}" ;;
6202 *) # relative path
6203   cache_file_option="--cache-file=../${cache_file}" ;;
6204 esac
6205
6206 # Host dirs don't like to share a cache file either, horribly enough.
6207 # This seems to be due to autoconf 2.5x stupidity.
6208 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6209
6210 target_configargs=${baseargs}
6211
6212 # Passing a --with-cross-host argument lets the target libraries know
6213 # whether they are being built with a cross-compiler or being built
6214 # native.  However, it would be better to use other mechanisms to make the
6215 # sorts of decisions they want to make on this basis.  Please consider
6216 # this option to be deprecated.  FIXME.
6217 if test x${is_cross_compiler} = xyes ; then
6218   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6219 fi
6220
6221 # Default to --enable-multilib.
6222 if test x${enable_multilib} = x ; then
6223   target_configargs="--enable-multilib ${target_configargs}"
6224 fi
6225
6226 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6227 # changed from the earlier setting of with_newlib.
6228 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6229   target_configargs="--with-newlib ${target_configargs}"
6230 fi
6231
6232 # Different target subdirs use different values of certain variables
6233 # (notably CXX).  Worse, multilibs use *lots* of different values.
6234 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6235 # it doesn't automatically accept command-line overrides of them.
6236 # This means it's not safe for target subdirs to share a cache file,
6237 # which is disgusting, but there you have it.  Hopefully this can be
6238 # fixed in future.  It's still worthwhile to use a cache file for each
6239 # directory.  I think.
6240
6241 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6242 # We need to pass --target, as newer autoconf's requires consistency
6243 # for target_alias and gcc doesn't manage it consistently.
6244 target_configargs="--cache-file=./config.cache ${target_configargs}"
6245
6246 FLAGS_FOR_TARGET=
6247 case " $target_configdirs " in
6248  *" newlib "*)
6249   case " $target_configargs " in
6250   *" --with-newlib "*)
6251    case "$target" in
6252    *-cygwin*)
6253      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' ;;
6254    esac
6255
6256    # If we're not building GCC, don't discard standard headers.
6257    if test -d ${srcdir}/gcc; then
6258      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6259
6260      if test "${build}" != "${host}"; then
6261        # On Canadian crosses, CC_FOR_TARGET will have already been set
6262        # by `configure', so we won't have an opportunity to add -Bgcc/
6263        # to it.  This is right: we don't want to search that directory
6264        # for binaries, but we want the header files in there, so add
6265        # them explicitly.
6266        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6267
6268        # Someone might think of using the pre-installed headers on
6269        # Canadian crosses, in case the installed compiler is not fully
6270        # compatible with the compiler being built.  In this case, it
6271        # would be better to flag an error than risking having
6272        # incompatible object files being constructed.  We can't
6273        # guarantee that an error will be flagged, but let's hope the
6274        # compiler will do it, when presented with incompatible header
6275        # files.
6276      fi
6277    fi
6278
6279    case "${target}-${is_cross_compiler}" in
6280    i[3456789]86-*-linux*-no)
6281       # Here host == target, so we don't need to build gcc,
6282       # so we don't want to discard standard headers.
6283       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6284       ;;
6285    *)
6286       # If we're building newlib, use its generic headers last, but search
6287       # for any libc-related directories first (so make it the last -B
6288       # switch).
6289       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6290
6291       # If we're building libgloss, find the startup file, simulator library
6292       # and linker script.
6293       case " $target_configdirs " in
6294         *" libgloss "*)
6295         # Look for startup file, simulator library and maybe linker script.
6296         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6297         # Look for libnosys.a in case the target needs it.
6298         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6299         # Most targets have the linker script in the source directory.
6300         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6301         ;;
6302       esac
6303       ;;
6304    esac
6305    ;;
6306   esac
6307   ;;
6308 esac
6309 case "$target" in
6310 *-mingw*)
6311   # Can't be handled as Cygwin above since Mingw does not use newlib.
6312   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' ;;
6313 esac
6314
6315 # Allow the user to override the flags for
6316 # our build compiler if desired.
6317 if test x"${build}" = x"${host}" ; then
6318   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6319   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6320   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6321 fi
6322
6323 # On Canadian crosses, we'll be searching the right directories for
6324 # the previously-installed cross compiler, so don't bother to add
6325 # flags for directories within the install tree of the compiler
6326 # being built; programs in there won't even run.
6327 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6328   # Search for pre-installed headers if nothing else fits.
6329   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6330 fi
6331
6332 if test "x${use_gnu_ld}" = x &&
6333    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6334   # Arrange for us to find uninstalled linker scripts.
6335   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6336 fi
6337
6338 # Search for other target-specific linker scripts and such.
6339 case "${target}" in
6340   mep*)
6341     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6342     ;;
6343 esac
6344
6345 # Makefile fragments.
6346 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6347 do
6348   eval fragval=\$$frag
6349   if test $fragval != /dev/null; then
6350     eval $frag=${srcdir}/$fragval
6351   fi
6352 done
6353
6354
6355
6356
6357
6358 # Miscellanea: directories, flags, etc.
6359
6360
6361
6362
6363
6364
6365
6366
6367 # Build module lists & subconfigure args.
6368
6369
6370
6371 # Host module lists & subconfigure args.
6372
6373
6374
6375 # Target module lists & subconfigure args.
6376
6377
6378
6379 # Build tools.
6380
6381
6382
6383
6384
6385
6386
6387
6388
6389
6390
6391
6392
6393
6394
6395
6396
6397 # Generate default definitions for YACC, M4, LEX and other programs that run
6398 # on the build machine.  These are used if the Makefile can't locate these
6399 # programs in objdir.
6400 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6401
6402 for ac_prog in 'bison -y' byacc yacc
6403 do
6404   # Extract the first word of "$ac_prog", so it can be a program name with args.
6405 set dummy $ac_prog; ac_word=$2
6406 echo "$as_me:$LINENO: checking for $ac_word" >&5
6407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6408 if test "${ac_cv_prog_YACC+set}" = set; then
6409   echo $ECHO_N "(cached) $ECHO_C" >&6
6410 else
6411   if test -n "$YACC"; then
6412   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6413 else
6414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6415 for as_dir in $PATH
6416 do
6417   IFS=$as_save_IFS
6418   test -z "$as_dir" && as_dir=.
6419   for ac_exec_ext in '' $ac_executable_extensions; do
6420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6421     ac_cv_prog_YACC="$ac_prog"
6422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6423     break 2
6424   fi
6425 done
6426 done
6427
6428 fi
6429 fi
6430 YACC=$ac_cv_prog_YACC
6431 if test -n "$YACC"; then
6432   echo "$as_me:$LINENO: result: $YACC" >&5
6433 echo "${ECHO_T}$YACC" >&6
6434 else
6435   echo "$as_me:$LINENO: result: no" >&5
6436 echo "${ECHO_T}no" >&6
6437 fi
6438
6439   test -n "$YACC" && break
6440 done
6441 test -n "$YACC" || YACC="$MISSING bison -y"
6442
6443 case " $build_configdirs " in
6444   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6445   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6446 esac
6447
6448 for ac_prog in bison
6449 do
6450   # Extract the first word of "$ac_prog", so it can be a program name with args.
6451 set dummy $ac_prog; ac_word=$2
6452 echo "$as_me:$LINENO: checking for $ac_word" >&5
6453 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6454 if test "${ac_cv_prog_BISON+set}" = set; then
6455   echo $ECHO_N "(cached) $ECHO_C" >&6
6456 else
6457   if test -n "$BISON"; then
6458   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6459 else
6460 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6461 for as_dir in $PATH
6462 do
6463   IFS=$as_save_IFS
6464   test -z "$as_dir" && as_dir=.
6465   for ac_exec_ext in '' $ac_executable_extensions; do
6466   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6467     ac_cv_prog_BISON="$ac_prog"
6468     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6469     break 2
6470   fi
6471 done
6472 done
6473
6474 fi
6475 fi
6476 BISON=$ac_cv_prog_BISON
6477 if test -n "$BISON"; then
6478   echo "$as_me:$LINENO: result: $BISON" >&5
6479 echo "${ECHO_T}$BISON" >&6
6480 else
6481   echo "$as_me:$LINENO: result: no" >&5
6482 echo "${ECHO_T}no" >&6
6483 fi
6484
6485   test -n "$BISON" && break
6486 done
6487 test -n "$BISON" || BISON="$MISSING bison"
6488
6489 case " $build_configdirs " in
6490   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6491 esac
6492
6493 for ac_prog in gm4 gnum4 m4
6494 do
6495   # Extract the first word of "$ac_prog", so it can be a program name with args.
6496 set dummy $ac_prog; ac_word=$2
6497 echo "$as_me:$LINENO: checking for $ac_word" >&5
6498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6499 if test "${ac_cv_prog_M4+set}" = set; then
6500   echo $ECHO_N "(cached) $ECHO_C" >&6
6501 else
6502   if test -n "$M4"; then
6503   ac_cv_prog_M4="$M4" # Let the user override the test.
6504 else
6505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6506 for as_dir in $PATH
6507 do
6508   IFS=$as_save_IFS
6509   test -z "$as_dir" && as_dir=.
6510   for ac_exec_ext in '' $ac_executable_extensions; do
6511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6512     ac_cv_prog_M4="$ac_prog"
6513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6514     break 2
6515   fi
6516 done
6517 done
6518
6519 fi
6520 fi
6521 M4=$ac_cv_prog_M4
6522 if test -n "$M4"; then
6523   echo "$as_me:$LINENO: result: $M4" >&5
6524 echo "${ECHO_T}$M4" >&6
6525 else
6526   echo "$as_me:$LINENO: result: no" >&5
6527 echo "${ECHO_T}no" >&6
6528 fi
6529
6530   test -n "$M4" && break
6531 done
6532 test -n "$M4" || M4="$MISSING m4"
6533
6534 case " $build_configdirs " in
6535   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6536 esac
6537
6538 for ac_prog in flex lex
6539 do
6540   # Extract the first word of "$ac_prog", so it can be a program name with args.
6541 set dummy $ac_prog; ac_word=$2
6542 echo "$as_me:$LINENO: checking for $ac_word" >&5
6543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6544 if test "${ac_cv_prog_LEX+set}" = set; then
6545   echo $ECHO_N "(cached) $ECHO_C" >&6
6546 else
6547   if test -n "$LEX"; then
6548   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6549 else
6550 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6551 for as_dir in $PATH
6552 do
6553   IFS=$as_save_IFS
6554   test -z "$as_dir" && as_dir=.
6555   for ac_exec_ext in '' $ac_executable_extensions; do
6556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6557     ac_cv_prog_LEX="$ac_prog"
6558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6559     break 2
6560   fi
6561 done
6562 done
6563
6564 fi
6565 fi
6566 LEX=$ac_cv_prog_LEX
6567 if test -n "$LEX"; then
6568   echo "$as_me:$LINENO: result: $LEX" >&5
6569 echo "${ECHO_T}$LEX" >&6
6570 else
6571   echo "$as_me:$LINENO: result: no" >&5
6572 echo "${ECHO_T}no" >&6
6573 fi
6574
6575   test -n "$LEX" && break
6576 done
6577 test -n "$LEX" || LEX="$MISSING flex"
6578
6579 case " $build_configdirs " in
6580   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6581   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6582 esac
6583
6584 for ac_prog in flex
6585 do
6586   # Extract the first word of "$ac_prog", so it can be a program name with args.
6587 set dummy $ac_prog; ac_word=$2
6588 echo "$as_me:$LINENO: checking for $ac_word" >&5
6589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6590 if test "${ac_cv_prog_FLEX+set}" = set; then
6591   echo $ECHO_N "(cached) $ECHO_C" >&6
6592 else
6593   if test -n "$FLEX"; then
6594   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6595 else
6596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6597 for as_dir in $PATH
6598 do
6599   IFS=$as_save_IFS
6600   test -z "$as_dir" && as_dir=.
6601   for ac_exec_ext in '' $ac_executable_extensions; do
6602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6603     ac_cv_prog_FLEX="$ac_prog"
6604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6605     break 2
6606   fi
6607 done
6608 done
6609
6610 fi
6611 fi
6612 FLEX=$ac_cv_prog_FLEX
6613 if test -n "$FLEX"; then
6614   echo "$as_me:$LINENO: result: $FLEX" >&5
6615 echo "${ECHO_T}$FLEX" >&6
6616 else
6617   echo "$as_me:$LINENO: result: no" >&5
6618 echo "${ECHO_T}no" >&6
6619 fi
6620
6621   test -n "$FLEX" && break
6622 done
6623 test -n "$FLEX" || FLEX="$MISSING flex"
6624
6625 case " $build_configdirs " in
6626   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6627 esac
6628
6629 for ac_prog in makeinfo
6630 do
6631   # Extract the first word of "$ac_prog", so it can be a program name with args.
6632 set dummy $ac_prog; ac_word=$2
6633 echo "$as_me:$LINENO: checking for $ac_word" >&5
6634 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6635 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6636   echo $ECHO_N "(cached) $ECHO_C" >&6
6637 else
6638   if test -n "$MAKEINFO"; then
6639   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6640 else
6641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6642 for as_dir in $PATH
6643 do
6644   IFS=$as_save_IFS
6645   test -z "$as_dir" && as_dir=.
6646   for ac_exec_ext in '' $ac_executable_extensions; do
6647   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6648     ac_cv_prog_MAKEINFO="$ac_prog"
6649     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6650     break 2
6651   fi
6652 done
6653 done
6654
6655 fi
6656 fi
6657 MAKEINFO=$ac_cv_prog_MAKEINFO
6658 if test -n "$MAKEINFO"; then
6659   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6660 echo "${ECHO_T}$MAKEINFO" >&6
6661 else
6662   echo "$as_me:$LINENO: result: no" >&5
6663 echo "${ECHO_T}no" >&6
6664 fi
6665
6666   test -n "$MAKEINFO" && break
6667 done
6668 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6669
6670 case " $build_configdirs " in
6671   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6672   *)
6673
6674     # For an installed makeinfo, we require it to be from texinfo 4.7 or
6675     # higher, else we use the "missing" dummy.
6676     if ${MAKEINFO} --version \
6677        | egrep 'texinfo[^0-9]*(4\.([7-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6678       :
6679     else
6680       MAKEINFO="$MISSING makeinfo"
6681     fi
6682     ;;
6683
6684 esac
6685
6686 # FIXME: expect and dejagnu may become build tools?
6687
6688 for ac_prog in expect
6689 do
6690   # Extract the first word of "$ac_prog", so it can be a program name with args.
6691 set dummy $ac_prog; ac_word=$2
6692 echo "$as_me:$LINENO: checking for $ac_word" >&5
6693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6694 if test "${ac_cv_prog_EXPECT+set}" = set; then
6695   echo $ECHO_N "(cached) $ECHO_C" >&6
6696 else
6697   if test -n "$EXPECT"; then
6698   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6699 else
6700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6701 for as_dir in $PATH
6702 do
6703   IFS=$as_save_IFS
6704   test -z "$as_dir" && as_dir=.
6705   for ac_exec_ext in '' $ac_executable_extensions; do
6706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6707     ac_cv_prog_EXPECT="$ac_prog"
6708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6709     break 2
6710   fi
6711 done
6712 done
6713
6714 fi
6715 fi
6716 EXPECT=$ac_cv_prog_EXPECT
6717 if test -n "$EXPECT"; then
6718   echo "$as_me:$LINENO: result: $EXPECT" >&5
6719 echo "${ECHO_T}$EXPECT" >&6
6720 else
6721   echo "$as_me:$LINENO: result: no" >&5
6722 echo "${ECHO_T}no" >&6
6723 fi
6724
6725   test -n "$EXPECT" && break
6726 done
6727 test -n "$EXPECT" || EXPECT="expect"
6728
6729 case " $configdirs " in
6730   *" expect "*)
6731     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6732     ;;
6733 esac
6734
6735 for ac_prog in runtest
6736 do
6737   # Extract the first word of "$ac_prog", so it can be a program name with args.
6738 set dummy $ac_prog; ac_word=$2
6739 echo "$as_me:$LINENO: checking for $ac_word" >&5
6740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6741 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6742   echo $ECHO_N "(cached) $ECHO_C" >&6
6743 else
6744   if test -n "$RUNTEST"; then
6745   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6746 else
6747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6748 for as_dir in $PATH
6749 do
6750   IFS=$as_save_IFS
6751   test -z "$as_dir" && as_dir=.
6752   for ac_exec_ext in '' $ac_executable_extensions; do
6753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6754     ac_cv_prog_RUNTEST="$ac_prog"
6755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6756     break 2
6757   fi
6758 done
6759 done
6760
6761 fi
6762 fi
6763 RUNTEST=$ac_cv_prog_RUNTEST
6764 if test -n "$RUNTEST"; then
6765   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6766 echo "${ECHO_T}$RUNTEST" >&6
6767 else
6768   echo "$as_me:$LINENO: result: no" >&5
6769 echo "${ECHO_T}no" >&6
6770 fi
6771
6772   test -n "$RUNTEST" && break
6773 done
6774 test -n "$RUNTEST" || RUNTEST="runtest"
6775
6776 case " $configdirs " in
6777   *" dejagnu "*)
6778     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6779     ;;
6780 esac
6781
6782
6783 # Host tools.
6784 ncn_tool_prefix=
6785 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6786 ncn_target_tool_prefix=
6787 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6788
6789
6790
6791 if test -n "$AR"; then
6792   ac_cv_prog_AR=$AR
6793 elif test -n "$ac_cv_prog_AR"; then
6794   AR=$ac_cv_prog_AR
6795 fi
6796
6797 if test -n "$ac_cv_prog_AR"; then
6798   for ncn_progname in ar; do
6799     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6800 set dummy ${ncn_progname}; ac_word=$2
6801 echo "$as_me:$LINENO: checking for $ac_word" >&5
6802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6803 if test "${ac_cv_prog_AR+set}" = set; then
6804   echo $ECHO_N "(cached) $ECHO_C" >&6
6805 else
6806   if test -n "$AR"; then
6807   ac_cv_prog_AR="$AR" # Let the user override the test.
6808 else
6809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6810 for as_dir in $PATH
6811 do
6812   IFS=$as_save_IFS
6813   test -z "$as_dir" && as_dir=.
6814   for ac_exec_ext in '' $ac_executable_extensions; do
6815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6816     ac_cv_prog_AR="${ncn_progname}"
6817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6818     break 2
6819   fi
6820 done
6821 done
6822
6823 fi
6824 fi
6825 AR=$ac_cv_prog_AR
6826 if test -n "$AR"; then
6827   echo "$as_me:$LINENO: result: $AR" >&5
6828 echo "${ECHO_T}$AR" >&6
6829 else
6830   echo "$as_me:$LINENO: result: no" >&5
6831 echo "${ECHO_T}no" >&6
6832 fi
6833
6834   done
6835 fi
6836
6837 for ncn_progname in ar; do
6838   if test -n "$ncn_tool_prefix"; then
6839     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6840 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6841 echo "$as_me:$LINENO: checking for $ac_word" >&5
6842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6843 if test "${ac_cv_prog_AR+set}" = set; then
6844   echo $ECHO_N "(cached) $ECHO_C" >&6
6845 else
6846   if test -n "$AR"; then
6847   ac_cv_prog_AR="$AR" # Let the user override the test.
6848 else
6849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6850 for as_dir in $PATH
6851 do
6852   IFS=$as_save_IFS
6853   test -z "$as_dir" && as_dir=.
6854   for ac_exec_ext in '' $ac_executable_extensions; do
6855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6856     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6858     break 2
6859   fi
6860 done
6861 done
6862
6863 fi
6864 fi
6865 AR=$ac_cv_prog_AR
6866 if test -n "$AR"; then
6867   echo "$as_me:$LINENO: result: $AR" >&5
6868 echo "${ECHO_T}$AR" >&6
6869 else
6870   echo "$as_me:$LINENO: result: no" >&5
6871 echo "${ECHO_T}no" >&6
6872 fi
6873
6874   fi
6875   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6876     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6877 set dummy ${ncn_progname}; ac_word=$2
6878 echo "$as_me:$LINENO: checking for $ac_word" >&5
6879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6880 if test "${ac_cv_prog_AR+set}" = set; then
6881   echo $ECHO_N "(cached) $ECHO_C" >&6
6882 else
6883   if test -n "$AR"; then
6884   ac_cv_prog_AR="$AR" # Let the user override the test.
6885 else
6886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6887 for as_dir in $PATH
6888 do
6889   IFS=$as_save_IFS
6890   test -z "$as_dir" && as_dir=.
6891   for ac_exec_ext in '' $ac_executable_extensions; do
6892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6893     ac_cv_prog_AR="${ncn_progname}"
6894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6895     break 2
6896   fi
6897 done
6898 done
6899
6900 fi
6901 fi
6902 AR=$ac_cv_prog_AR
6903 if test -n "$AR"; then
6904   echo "$as_me:$LINENO: result: $AR" >&5
6905 echo "${ECHO_T}$AR" >&6
6906 else
6907   echo "$as_me:$LINENO: result: no" >&5
6908 echo "${ECHO_T}no" >&6
6909 fi
6910
6911   fi
6912   test -n "$ac_cv_prog_AR" && break
6913 done
6914
6915 if test -z "$ac_cv_prog_AR" ; then
6916   set dummy ar
6917   if test $build = $host ; then
6918     AR="$2"
6919   else
6920     AR="${ncn_tool_prefix}$2"
6921   fi
6922 fi
6923
6924
6925
6926 if test -n "$AS"; then
6927   ac_cv_prog_AS=$AS
6928 elif test -n "$ac_cv_prog_AS"; then
6929   AS=$ac_cv_prog_AS
6930 fi
6931
6932 if test -n "$ac_cv_prog_AS"; then
6933   for ncn_progname in as; do
6934     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6935 set dummy ${ncn_progname}; ac_word=$2
6936 echo "$as_me:$LINENO: checking for $ac_word" >&5
6937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6938 if test "${ac_cv_prog_AS+set}" = set; then
6939   echo $ECHO_N "(cached) $ECHO_C" >&6
6940 else
6941   if test -n "$AS"; then
6942   ac_cv_prog_AS="$AS" # Let the user override the test.
6943 else
6944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6945 for as_dir in $PATH
6946 do
6947   IFS=$as_save_IFS
6948   test -z "$as_dir" && as_dir=.
6949   for ac_exec_ext in '' $ac_executable_extensions; do
6950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6951     ac_cv_prog_AS="${ncn_progname}"
6952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6953     break 2
6954   fi
6955 done
6956 done
6957
6958 fi
6959 fi
6960 AS=$ac_cv_prog_AS
6961 if test -n "$AS"; then
6962   echo "$as_me:$LINENO: result: $AS" >&5
6963 echo "${ECHO_T}$AS" >&6
6964 else
6965   echo "$as_me:$LINENO: result: no" >&5
6966 echo "${ECHO_T}no" >&6
6967 fi
6968
6969   done
6970 fi
6971
6972 for ncn_progname in as; do
6973   if test -n "$ncn_tool_prefix"; then
6974     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6975 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6976 echo "$as_me:$LINENO: checking for $ac_word" >&5
6977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6978 if test "${ac_cv_prog_AS+set}" = set; then
6979   echo $ECHO_N "(cached) $ECHO_C" >&6
6980 else
6981   if test -n "$AS"; then
6982   ac_cv_prog_AS="$AS" # Let the user override the test.
6983 else
6984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6985 for as_dir in $PATH
6986 do
6987   IFS=$as_save_IFS
6988   test -z "$as_dir" && as_dir=.
6989   for ac_exec_ext in '' $ac_executable_extensions; do
6990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6991     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6993     break 2
6994   fi
6995 done
6996 done
6997
6998 fi
6999 fi
7000 AS=$ac_cv_prog_AS
7001 if test -n "$AS"; then
7002   echo "$as_me:$LINENO: result: $AS" >&5
7003 echo "${ECHO_T}$AS" >&6
7004 else
7005   echo "$as_me:$LINENO: result: no" >&5
7006 echo "${ECHO_T}no" >&6
7007 fi
7008
7009   fi
7010   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
7011     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7012 set dummy ${ncn_progname}; ac_word=$2
7013 echo "$as_me:$LINENO: checking for $ac_word" >&5
7014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7015 if test "${ac_cv_prog_AS+set}" = set; then
7016   echo $ECHO_N "(cached) $ECHO_C" >&6
7017 else
7018   if test -n "$AS"; then
7019   ac_cv_prog_AS="$AS" # Let the user override the test.
7020 else
7021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7022 for as_dir in $PATH
7023 do
7024   IFS=$as_save_IFS
7025   test -z "$as_dir" && as_dir=.
7026   for ac_exec_ext in '' $ac_executable_extensions; do
7027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7028     ac_cv_prog_AS="${ncn_progname}"
7029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7030     break 2
7031   fi
7032 done
7033 done
7034
7035 fi
7036 fi
7037 AS=$ac_cv_prog_AS
7038 if test -n "$AS"; then
7039   echo "$as_me:$LINENO: result: $AS" >&5
7040 echo "${ECHO_T}$AS" >&6
7041 else
7042   echo "$as_me:$LINENO: result: no" >&5
7043 echo "${ECHO_T}no" >&6
7044 fi
7045
7046   fi
7047   test -n "$ac_cv_prog_AS" && break
7048 done
7049
7050 if test -z "$ac_cv_prog_AS" ; then
7051   set dummy as
7052   if test $build = $host ; then
7053     AS="$2"
7054   else
7055     AS="${ncn_tool_prefix}$2"
7056   fi
7057 fi
7058
7059
7060
7061 if test -n "$DLLTOOL"; then
7062   ac_cv_prog_DLLTOOL=$DLLTOOL
7063 elif test -n "$ac_cv_prog_DLLTOOL"; then
7064   DLLTOOL=$ac_cv_prog_DLLTOOL
7065 fi
7066
7067 if test -n "$ac_cv_prog_DLLTOOL"; then
7068   for ncn_progname in dlltool; do
7069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7070 set dummy ${ncn_progname}; ac_word=$2
7071 echo "$as_me:$LINENO: checking for $ac_word" >&5
7072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7073 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7074   echo $ECHO_N "(cached) $ECHO_C" >&6
7075 else
7076   if test -n "$DLLTOOL"; then
7077   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7078 else
7079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7080 for as_dir in $PATH
7081 do
7082   IFS=$as_save_IFS
7083   test -z "$as_dir" && as_dir=.
7084   for ac_exec_ext in '' $ac_executable_extensions; do
7085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7086     ac_cv_prog_DLLTOOL="${ncn_progname}"
7087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7088     break 2
7089   fi
7090 done
7091 done
7092
7093 fi
7094 fi
7095 DLLTOOL=$ac_cv_prog_DLLTOOL
7096 if test -n "$DLLTOOL"; then
7097   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7098 echo "${ECHO_T}$DLLTOOL" >&6
7099 else
7100   echo "$as_me:$LINENO: result: no" >&5
7101 echo "${ECHO_T}no" >&6
7102 fi
7103
7104   done
7105 fi
7106
7107 for ncn_progname in dlltool; do
7108   if test -n "$ncn_tool_prefix"; then
7109     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7110 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7111 echo "$as_me:$LINENO: checking for $ac_word" >&5
7112 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7113 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7114   echo $ECHO_N "(cached) $ECHO_C" >&6
7115 else
7116   if test -n "$DLLTOOL"; then
7117   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7118 else
7119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7120 for as_dir in $PATH
7121 do
7122   IFS=$as_save_IFS
7123   test -z "$as_dir" && as_dir=.
7124   for ac_exec_ext in '' $ac_executable_extensions; do
7125   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7126     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7127     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7128     break 2
7129   fi
7130 done
7131 done
7132
7133 fi
7134 fi
7135 DLLTOOL=$ac_cv_prog_DLLTOOL
7136 if test -n "$DLLTOOL"; then
7137   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7138 echo "${ECHO_T}$DLLTOOL" >&6
7139 else
7140   echo "$as_me:$LINENO: result: no" >&5
7141 echo "${ECHO_T}no" >&6
7142 fi
7143
7144   fi
7145   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7146     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7147 set dummy ${ncn_progname}; ac_word=$2
7148 echo "$as_me:$LINENO: checking for $ac_word" >&5
7149 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7150 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7151   echo $ECHO_N "(cached) $ECHO_C" >&6
7152 else
7153   if test -n "$DLLTOOL"; then
7154   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7155 else
7156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7157 for as_dir in $PATH
7158 do
7159   IFS=$as_save_IFS
7160   test -z "$as_dir" && as_dir=.
7161   for ac_exec_ext in '' $ac_executable_extensions; do
7162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7163     ac_cv_prog_DLLTOOL="${ncn_progname}"
7164     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7165     break 2
7166   fi
7167 done
7168 done
7169
7170 fi
7171 fi
7172 DLLTOOL=$ac_cv_prog_DLLTOOL
7173 if test -n "$DLLTOOL"; then
7174   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7175 echo "${ECHO_T}$DLLTOOL" >&6
7176 else
7177   echo "$as_me:$LINENO: result: no" >&5
7178 echo "${ECHO_T}no" >&6
7179 fi
7180
7181   fi
7182   test -n "$ac_cv_prog_DLLTOOL" && break
7183 done
7184
7185 if test -z "$ac_cv_prog_DLLTOOL" ; then
7186   set dummy dlltool
7187   if test $build = $host ; then
7188     DLLTOOL="$2"
7189   else
7190     DLLTOOL="${ncn_tool_prefix}$2"
7191   fi
7192 fi
7193
7194
7195
7196 if test -n "$LD"; then
7197   ac_cv_prog_LD=$LD
7198 elif test -n "$ac_cv_prog_LD"; then
7199   LD=$ac_cv_prog_LD
7200 fi
7201
7202 if test -n "$ac_cv_prog_LD"; then
7203   for ncn_progname in ld; do
7204     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7205 set dummy ${ncn_progname}; ac_word=$2
7206 echo "$as_me:$LINENO: checking for $ac_word" >&5
7207 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7208 if test "${ac_cv_prog_LD+set}" = set; then
7209   echo $ECHO_N "(cached) $ECHO_C" >&6
7210 else
7211   if test -n "$LD"; then
7212   ac_cv_prog_LD="$LD" # Let the user override the test.
7213 else
7214 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7215 for as_dir in $PATH
7216 do
7217   IFS=$as_save_IFS
7218   test -z "$as_dir" && as_dir=.
7219   for ac_exec_ext in '' $ac_executable_extensions; do
7220   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7221     ac_cv_prog_LD="${ncn_progname}"
7222     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7223     break 2
7224   fi
7225 done
7226 done
7227
7228 fi
7229 fi
7230 LD=$ac_cv_prog_LD
7231 if test -n "$LD"; then
7232   echo "$as_me:$LINENO: result: $LD" >&5
7233 echo "${ECHO_T}$LD" >&6
7234 else
7235   echo "$as_me:$LINENO: result: no" >&5
7236 echo "${ECHO_T}no" >&6
7237 fi
7238
7239   done
7240 fi
7241
7242 for ncn_progname in ld; do
7243   if test -n "$ncn_tool_prefix"; then
7244     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7245 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7246 echo "$as_me:$LINENO: checking for $ac_word" >&5
7247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7248 if test "${ac_cv_prog_LD+set}" = set; then
7249   echo $ECHO_N "(cached) $ECHO_C" >&6
7250 else
7251   if test -n "$LD"; then
7252   ac_cv_prog_LD="$LD" # Let the user override the test.
7253 else
7254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7255 for as_dir in $PATH
7256 do
7257   IFS=$as_save_IFS
7258   test -z "$as_dir" && as_dir=.
7259   for ac_exec_ext in '' $ac_executable_extensions; do
7260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7261     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7263     break 2
7264   fi
7265 done
7266 done
7267
7268 fi
7269 fi
7270 LD=$ac_cv_prog_LD
7271 if test -n "$LD"; then
7272   echo "$as_me:$LINENO: result: $LD" >&5
7273 echo "${ECHO_T}$LD" >&6
7274 else
7275   echo "$as_me:$LINENO: result: no" >&5
7276 echo "${ECHO_T}no" >&6
7277 fi
7278
7279   fi
7280   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7281     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7282 set dummy ${ncn_progname}; ac_word=$2
7283 echo "$as_me:$LINENO: checking for $ac_word" >&5
7284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7285 if test "${ac_cv_prog_LD+set}" = set; then
7286   echo $ECHO_N "(cached) $ECHO_C" >&6
7287 else
7288   if test -n "$LD"; then
7289   ac_cv_prog_LD="$LD" # Let the user override the test.
7290 else
7291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7292 for as_dir in $PATH
7293 do
7294   IFS=$as_save_IFS
7295   test -z "$as_dir" && as_dir=.
7296   for ac_exec_ext in '' $ac_executable_extensions; do
7297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7298     ac_cv_prog_LD="${ncn_progname}"
7299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7300     break 2
7301   fi
7302 done
7303 done
7304
7305 fi
7306 fi
7307 LD=$ac_cv_prog_LD
7308 if test -n "$LD"; then
7309   echo "$as_me:$LINENO: result: $LD" >&5
7310 echo "${ECHO_T}$LD" >&6
7311 else
7312   echo "$as_me:$LINENO: result: no" >&5
7313 echo "${ECHO_T}no" >&6
7314 fi
7315
7316   fi
7317   test -n "$ac_cv_prog_LD" && break
7318 done
7319
7320 if test -z "$ac_cv_prog_LD" ; then
7321   set dummy ld
7322   if test $build = $host ; then
7323     LD="$2"
7324   else
7325     LD="${ncn_tool_prefix}$2"
7326   fi
7327 fi
7328
7329
7330
7331 if test -n "$LIPO"; then
7332   ac_cv_prog_LIPO=$LIPO
7333 elif test -n "$ac_cv_prog_LIPO"; then
7334   LIPO=$ac_cv_prog_LIPO
7335 fi
7336
7337 if test -n "$ac_cv_prog_LIPO"; then
7338   for ncn_progname in lipo; do
7339     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7340 set dummy ${ncn_progname}; ac_word=$2
7341 echo "$as_me:$LINENO: checking for $ac_word" >&5
7342 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7343 if test "${ac_cv_prog_LIPO+set}" = set; then
7344   echo $ECHO_N "(cached) $ECHO_C" >&6
7345 else
7346   if test -n "$LIPO"; then
7347   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7348 else
7349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7350 for as_dir in $PATH
7351 do
7352   IFS=$as_save_IFS
7353   test -z "$as_dir" && as_dir=.
7354   for ac_exec_ext in '' $ac_executable_extensions; do
7355   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7356     ac_cv_prog_LIPO="${ncn_progname}"
7357     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7358     break 2
7359   fi
7360 done
7361 done
7362
7363 fi
7364 fi
7365 LIPO=$ac_cv_prog_LIPO
7366 if test -n "$LIPO"; then
7367   echo "$as_me:$LINENO: result: $LIPO" >&5
7368 echo "${ECHO_T}$LIPO" >&6
7369 else
7370   echo "$as_me:$LINENO: result: no" >&5
7371 echo "${ECHO_T}no" >&6
7372 fi
7373
7374   done
7375 fi
7376
7377 for ncn_progname in lipo; do
7378   if test -n "$ncn_tool_prefix"; then
7379     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7380 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7381 echo "$as_me:$LINENO: checking for $ac_word" >&5
7382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7383 if test "${ac_cv_prog_LIPO+set}" = set; then
7384   echo $ECHO_N "(cached) $ECHO_C" >&6
7385 else
7386   if test -n "$LIPO"; then
7387   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7388 else
7389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7390 for as_dir in $PATH
7391 do
7392   IFS=$as_save_IFS
7393   test -z "$as_dir" && as_dir=.
7394   for ac_exec_ext in '' $ac_executable_extensions; do
7395   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7396     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7397     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7398     break 2
7399   fi
7400 done
7401 done
7402
7403 fi
7404 fi
7405 LIPO=$ac_cv_prog_LIPO
7406 if test -n "$LIPO"; then
7407   echo "$as_me:$LINENO: result: $LIPO" >&5
7408 echo "${ECHO_T}$LIPO" >&6
7409 else
7410   echo "$as_me:$LINENO: result: no" >&5
7411 echo "${ECHO_T}no" >&6
7412 fi
7413
7414   fi
7415   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7416     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7417 set dummy ${ncn_progname}; ac_word=$2
7418 echo "$as_me:$LINENO: checking for $ac_word" >&5
7419 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7420 if test "${ac_cv_prog_LIPO+set}" = set; then
7421   echo $ECHO_N "(cached) $ECHO_C" >&6
7422 else
7423   if test -n "$LIPO"; then
7424   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7425 else
7426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7427 for as_dir in $PATH
7428 do
7429   IFS=$as_save_IFS
7430   test -z "$as_dir" && as_dir=.
7431   for ac_exec_ext in '' $ac_executable_extensions; do
7432   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7433     ac_cv_prog_LIPO="${ncn_progname}"
7434     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7435     break 2
7436   fi
7437 done
7438 done
7439
7440 fi
7441 fi
7442 LIPO=$ac_cv_prog_LIPO
7443 if test -n "$LIPO"; then
7444   echo "$as_me:$LINENO: result: $LIPO" >&5
7445 echo "${ECHO_T}$LIPO" >&6
7446 else
7447   echo "$as_me:$LINENO: result: no" >&5
7448 echo "${ECHO_T}no" >&6
7449 fi
7450
7451   fi
7452   test -n "$ac_cv_prog_LIPO" && break
7453 done
7454
7455 if test -z "$ac_cv_prog_LIPO" ; then
7456   set dummy lipo
7457   if test $build = $host ; then
7458     LIPO="$2"
7459   else
7460     LIPO="${ncn_tool_prefix}$2"
7461   fi
7462 fi
7463
7464
7465
7466 if test -n "$NM"; then
7467   ac_cv_prog_NM=$NM
7468 elif test -n "$ac_cv_prog_NM"; then
7469   NM=$ac_cv_prog_NM
7470 fi
7471
7472 if test -n "$ac_cv_prog_NM"; then
7473   for ncn_progname in nm; do
7474     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7475 set dummy ${ncn_progname}; ac_word=$2
7476 echo "$as_me:$LINENO: checking for $ac_word" >&5
7477 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7478 if test "${ac_cv_prog_NM+set}" = set; then
7479   echo $ECHO_N "(cached) $ECHO_C" >&6
7480 else
7481   if test -n "$NM"; then
7482   ac_cv_prog_NM="$NM" # Let the user override the test.
7483 else
7484 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7485 for as_dir in $PATH
7486 do
7487   IFS=$as_save_IFS
7488   test -z "$as_dir" && as_dir=.
7489   for ac_exec_ext in '' $ac_executable_extensions; do
7490   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7491     ac_cv_prog_NM="${ncn_progname}"
7492     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7493     break 2
7494   fi
7495 done
7496 done
7497
7498 fi
7499 fi
7500 NM=$ac_cv_prog_NM
7501 if test -n "$NM"; then
7502   echo "$as_me:$LINENO: result: $NM" >&5
7503 echo "${ECHO_T}$NM" >&6
7504 else
7505   echo "$as_me:$LINENO: result: no" >&5
7506 echo "${ECHO_T}no" >&6
7507 fi
7508
7509   done
7510 fi
7511
7512 for ncn_progname in nm; do
7513   if test -n "$ncn_tool_prefix"; then
7514     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7515 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7516 echo "$as_me:$LINENO: checking for $ac_word" >&5
7517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7518 if test "${ac_cv_prog_NM+set}" = set; then
7519   echo $ECHO_N "(cached) $ECHO_C" >&6
7520 else
7521   if test -n "$NM"; then
7522   ac_cv_prog_NM="$NM" # Let the user override the test.
7523 else
7524 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7525 for as_dir in $PATH
7526 do
7527   IFS=$as_save_IFS
7528   test -z "$as_dir" && as_dir=.
7529   for ac_exec_ext in '' $ac_executable_extensions; do
7530   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7531     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7532     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7533     break 2
7534   fi
7535 done
7536 done
7537
7538 fi
7539 fi
7540 NM=$ac_cv_prog_NM
7541 if test -n "$NM"; then
7542   echo "$as_me:$LINENO: result: $NM" >&5
7543 echo "${ECHO_T}$NM" >&6
7544 else
7545   echo "$as_me:$LINENO: result: no" >&5
7546 echo "${ECHO_T}no" >&6
7547 fi
7548
7549   fi
7550   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7551     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7552 set dummy ${ncn_progname}; ac_word=$2
7553 echo "$as_me:$LINENO: checking for $ac_word" >&5
7554 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7555 if test "${ac_cv_prog_NM+set}" = set; then
7556   echo $ECHO_N "(cached) $ECHO_C" >&6
7557 else
7558   if test -n "$NM"; then
7559   ac_cv_prog_NM="$NM" # Let the user override the test.
7560 else
7561 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7562 for as_dir in $PATH
7563 do
7564   IFS=$as_save_IFS
7565   test -z "$as_dir" && as_dir=.
7566   for ac_exec_ext in '' $ac_executable_extensions; do
7567   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7568     ac_cv_prog_NM="${ncn_progname}"
7569     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7570     break 2
7571   fi
7572 done
7573 done
7574
7575 fi
7576 fi
7577 NM=$ac_cv_prog_NM
7578 if test -n "$NM"; then
7579   echo "$as_me:$LINENO: result: $NM" >&5
7580 echo "${ECHO_T}$NM" >&6
7581 else
7582   echo "$as_me:$LINENO: result: no" >&5
7583 echo "${ECHO_T}no" >&6
7584 fi
7585
7586   fi
7587   test -n "$ac_cv_prog_NM" && break
7588 done
7589
7590 if test -z "$ac_cv_prog_NM" ; then
7591   set dummy nm
7592   if test $build = $host ; then
7593     NM="$2"
7594   else
7595     NM="${ncn_tool_prefix}$2"
7596   fi
7597 fi
7598
7599
7600
7601 if test -n "$RANLIB"; then
7602   ac_cv_prog_RANLIB=$RANLIB
7603 elif test -n "$ac_cv_prog_RANLIB"; then
7604   RANLIB=$ac_cv_prog_RANLIB
7605 fi
7606
7607 if test -n "$ac_cv_prog_RANLIB"; then
7608   for ncn_progname in ranlib; do
7609     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7610 set dummy ${ncn_progname}; ac_word=$2
7611 echo "$as_me:$LINENO: checking for $ac_word" >&5
7612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7613 if test "${ac_cv_prog_RANLIB+set}" = set; then
7614   echo $ECHO_N "(cached) $ECHO_C" >&6
7615 else
7616   if test -n "$RANLIB"; then
7617   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7618 else
7619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7620 for as_dir in $PATH
7621 do
7622   IFS=$as_save_IFS
7623   test -z "$as_dir" && as_dir=.
7624   for ac_exec_ext in '' $ac_executable_extensions; do
7625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7626     ac_cv_prog_RANLIB="${ncn_progname}"
7627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7628     break 2
7629   fi
7630 done
7631 done
7632
7633 fi
7634 fi
7635 RANLIB=$ac_cv_prog_RANLIB
7636 if test -n "$RANLIB"; then
7637   echo "$as_me:$LINENO: result: $RANLIB" >&5
7638 echo "${ECHO_T}$RANLIB" >&6
7639 else
7640   echo "$as_me:$LINENO: result: no" >&5
7641 echo "${ECHO_T}no" >&6
7642 fi
7643
7644   done
7645 fi
7646
7647 for ncn_progname in ranlib; do
7648   if test -n "$ncn_tool_prefix"; then
7649     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7650 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7651 echo "$as_me:$LINENO: checking for $ac_word" >&5
7652 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7653 if test "${ac_cv_prog_RANLIB+set}" = set; then
7654   echo $ECHO_N "(cached) $ECHO_C" >&6
7655 else
7656   if test -n "$RANLIB"; then
7657   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7658 else
7659 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7660 for as_dir in $PATH
7661 do
7662   IFS=$as_save_IFS
7663   test -z "$as_dir" && as_dir=.
7664   for ac_exec_ext in '' $ac_executable_extensions; do
7665   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7666     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7667     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7668     break 2
7669   fi
7670 done
7671 done
7672
7673 fi
7674 fi
7675 RANLIB=$ac_cv_prog_RANLIB
7676 if test -n "$RANLIB"; then
7677   echo "$as_me:$LINENO: result: $RANLIB" >&5
7678 echo "${ECHO_T}$RANLIB" >&6
7679 else
7680   echo "$as_me:$LINENO: result: no" >&5
7681 echo "${ECHO_T}no" >&6
7682 fi
7683
7684   fi
7685   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7686     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7687 set dummy ${ncn_progname}; ac_word=$2
7688 echo "$as_me:$LINENO: checking for $ac_word" >&5
7689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7690 if test "${ac_cv_prog_RANLIB+set}" = set; then
7691   echo $ECHO_N "(cached) $ECHO_C" >&6
7692 else
7693   if test -n "$RANLIB"; then
7694   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7695 else
7696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7697 for as_dir in $PATH
7698 do
7699   IFS=$as_save_IFS
7700   test -z "$as_dir" && as_dir=.
7701   for ac_exec_ext in '' $ac_executable_extensions; do
7702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7703     ac_cv_prog_RANLIB="${ncn_progname}"
7704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7705     break 2
7706   fi
7707 done
7708 done
7709
7710 fi
7711 fi
7712 RANLIB=$ac_cv_prog_RANLIB
7713 if test -n "$RANLIB"; then
7714   echo "$as_me:$LINENO: result: $RANLIB" >&5
7715 echo "${ECHO_T}$RANLIB" >&6
7716 else
7717   echo "$as_me:$LINENO: result: no" >&5
7718 echo "${ECHO_T}no" >&6
7719 fi
7720
7721   fi
7722   test -n "$ac_cv_prog_RANLIB" && break
7723 done
7724
7725 if test -z "$ac_cv_prog_RANLIB" ; then
7726   RANLIB=":"
7727 fi
7728
7729
7730
7731 if test -n "$STRIP"; then
7732   ac_cv_prog_STRIP=$STRIP
7733 elif test -n "$ac_cv_prog_STRIP"; then
7734   STRIP=$ac_cv_prog_STRIP
7735 fi
7736
7737 if test -n "$ac_cv_prog_STRIP"; then
7738   for ncn_progname in strip; do
7739     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7740 set dummy ${ncn_progname}; ac_word=$2
7741 echo "$as_me:$LINENO: checking for $ac_word" >&5
7742 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7743 if test "${ac_cv_prog_STRIP+set}" = set; then
7744   echo $ECHO_N "(cached) $ECHO_C" >&6
7745 else
7746   if test -n "$STRIP"; then
7747   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7748 else
7749 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7750 for as_dir in $PATH
7751 do
7752   IFS=$as_save_IFS
7753   test -z "$as_dir" && as_dir=.
7754   for ac_exec_ext in '' $ac_executable_extensions; do
7755   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7756     ac_cv_prog_STRIP="${ncn_progname}"
7757     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7758     break 2
7759   fi
7760 done
7761 done
7762
7763 fi
7764 fi
7765 STRIP=$ac_cv_prog_STRIP
7766 if test -n "$STRIP"; then
7767   echo "$as_me:$LINENO: result: $STRIP" >&5
7768 echo "${ECHO_T}$STRIP" >&6
7769 else
7770   echo "$as_me:$LINENO: result: no" >&5
7771 echo "${ECHO_T}no" >&6
7772 fi
7773
7774   done
7775 fi
7776
7777 for ncn_progname in strip; do
7778   if test -n "$ncn_tool_prefix"; then
7779     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7780 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7781 echo "$as_me:$LINENO: checking for $ac_word" >&5
7782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7783 if test "${ac_cv_prog_STRIP+set}" = set; then
7784   echo $ECHO_N "(cached) $ECHO_C" >&6
7785 else
7786   if test -n "$STRIP"; then
7787   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7788 else
7789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7790 for as_dir in $PATH
7791 do
7792   IFS=$as_save_IFS
7793   test -z "$as_dir" && as_dir=.
7794   for ac_exec_ext in '' $ac_executable_extensions; do
7795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7796     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7798     break 2
7799   fi
7800 done
7801 done
7802
7803 fi
7804 fi
7805 STRIP=$ac_cv_prog_STRIP
7806 if test -n "$STRIP"; then
7807   echo "$as_me:$LINENO: result: $STRIP" >&5
7808 echo "${ECHO_T}$STRIP" >&6
7809 else
7810   echo "$as_me:$LINENO: result: no" >&5
7811 echo "${ECHO_T}no" >&6
7812 fi
7813
7814   fi
7815   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7816     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7817 set dummy ${ncn_progname}; ac_word=$2
7818 echo "$as_me:$LINENO: checking for $ac_word" >&5
7819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7820 if test "${ac_cv_prog_STRIP+set}" = set; then
7821   echo $ECHO_N "(cached) $ECHO_C" >&6
7822 else
7823   if test -n "$STRIP"; then
7824   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7825 else
7826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7827 for as_dir in $PATH
7828 do
7829   IFS=$as_save_IFS
7830   test -z "$as_dir" && as_dir=.
7831   for ac_exec_ext in '' $ac_executable_extensions; do
7832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7833     ac_cv_prog_STRIP="${ncn_progname}"
7834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7835     break 2
7836   fi
7837 done
7838 done
7839
7840 fi
7841 fi
7842 STRIP=$ac_cv_prog_STRIP
7843 if test -n "$STRIP"; then
7844   echo "$as_me:$LINENO: result: $STRIP" >&5
7845 echo "${ECHO_T}$STRIP" >&6
7846 else
7847   echo "$as_me:$LINENO: result: no" >&5
7848 echo "${ECHO_T}no" >&6
7849 fi
7850
7851   fi
7852   test -n "$ac_cv_prog_STRIP" && break
7853 done
7854
7855 if test -z "$ac_cv_prog_STRIP" ; then
7856   STRIP=":"
7857 fi
7858
7859
7860
7861 if test -n "$WINDRES"; then
7862   ac_cv_prog_WINDRES=$WINDRES
7863 elif test -n "$ac_cv_prog_WINDRES"; then
7864   WINDRES=$ac_cv_prog_WINDRES
7865 fi
7866
7867 if test -n "$ac_cv_prog_WINDRES"; then
7868   for ncn_progname in windres; do
7869     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7870 set dummy ${ncn_progname}; ac_word=$2
7871 echo "$as_me:$LINENO: checking for $ac_word" >&5
7872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7873 if test "${ac_cv_prog_WINDRES+set}" = set; then
7874   echo $ECHO_N "(cached) $ECHO_C" >&6
7875 else
7876   if test -n "$WINDRES"; then
7877   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7878 else
7879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7880 for as_dir in $PATH
7881 do
7882   IFS=$as_save_IFS
7883   test -z "$as_dir" && as_dir=.
7884   for ac_exec_ext in '' $ac_executable_extensions; do
7885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7886     ac_cv_prog_WINDRES="${ncn_progname}"
7887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7888     break 2
7889   fi
7890 done
7891 done
7892
7893 fi
7894 fi
7895 WINDRES=$ac_cv_prog_WINDRES
7896 if test -n "$WINDRES"; then
7897   echo "$as_me:$LINENO: result: $WINDRES" >&5
7898 echo "${ECHO_T}$WINDRES" >&6
7899 else
7900   echo "$as_me:$LINENO: result: no" >&5
7901 echo "${ECHO_T}no" >&6
7902 fi
7903
7904   done
7905 fi
7906
7907 for ncn_progname in windres; do
7908   if test -n "$ncn_tool_prefix"; then
7909     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7910 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7911 echo "$as_me:$LINENO: checking for $ac_word" >&5
7912 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7913 if test "${ac_cv_prog_WINDRES+set}" = set; then
7914   echo $ECHO_N "(cached) $ECHO_C" >&6
7915 else
7916   if test -n "$WINDRES"; then
7917   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7918 else
7919 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7920 for as_dir in $PATH
7921 do
7922   IFS=$as_save_IFS
7923   test -z "$as_dir" && as_dir=.
7924   for ac_exec_ext in '' $ac_executable_extensions; do
7925   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7926     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7927     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7928     break 2
7929   fi
7930 done
7931 done
7932
7933 fi
7934 fi
7935 WINDRES=$ac_cv_prog_WINDRES
7936 if test -n "$WINDRES"; then
7937   echo "$as_me:$LINENO: result: $WINDRES" >&5
7938 echo "${ECHO_T}$WINDRES" >&6
7939 else
7940   echo "$as_me:$LINENO: result: no" >&5
7941 echo "${ECHO_T}no" >&6
7942 fi
7943
7944   fi
7945   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7946     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7947 set dummy ${ncn_progname}; ac_word=$2
7948 echo "$as_me:$LINENO: checking for $ac_word" >&5
7949 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7950 if test "${ac_cv_prog_WINDRES+set}" = set; then
7951   echo $ECHO_N "(cached) $ECHO_C" >&6
7952 else
7953   if test -n "$WINDRES"; then
7954   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7955 else
7956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7957 for as_dir in $PATH
7958 do
7959   IFS=$as_save_IFS
7960   test -z "$as_dir" && as_dir=.
7961   for ac_exec_ext in '' $ac_executable_extensions; do
7962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7963     ac_cv_prog_WINDRES="${ncn_progname}"
7964     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7965     break 2
7966   fi
7967 done
7968 done
7969
7970 fi
7971 fi
7972 WINDRES=$ac_cv_prog_WINDRES
7973 if test -n "$WINDRES"; then
7974   echo "$as_me:$LINENO: result: $WINDRES" >&5
7975 echo "${ECHO_T}$WINDRES" >&6
7976 else
7977   echo "$as_me:$LINENO: result: no" >&5
7978 echo "${ECHO_T}no" >&6
7979 fi
7980
7981   fi
7982   test -n "$ac_cv_prog_WINDRES" && break
7983 done
7984
7985 if test -z "$ac_cv_prog_WINDRES" ; then
7986   set dummy windres
7987   if test $build = $host ; then
7988     WINDRES="$2"
7989   else
7990     WINDRES="${ncn_tool_prefix}$2"
7991   fi
7992 fi
7993
7994
7995
7996 if test -n "$WINDMC"; then
7997   ac_cv_prog_WINDMC=$WINDMC
7998 elif test -n "$ac_cv_prog_WINDMC"; then
7999   WINDMC=$ac_cv_prog_WINDMC
8000 fi
8001
8002 if test -n "$ac_cv_prog_WINDMC"; then
8003   for ncn_progname in windmc; do
8004     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8005 set dummy ${ncn_progname}; ac_word=$2
8006 echo "$as_me:$LINENO: checking for $ac_word" >&5
8007 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8008 if test "${ac_cv_prog_WINDMC+set}" = set; then
8009   echo $ECHO_N "(cached) $ECHO_C" >&6
8010 else
8011   if test -n "$WINDMC"; then
8012   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8013 else
8014 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8015 for as_dir in $PATH
8016 do
8017   IFS=$as_save_IFS
8018   test -z "$as_dir" && as_dir=.
8019   for ac_exec_ext in '' $ac_executable_extensions; do
8020   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8021     ac_cv_prog_WINDMC="${ncn_progname}"
8022     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8023     break 2
8024   fi
8025 done
8026 done
8027
8028 fi
8029 fi
8030 WINDMC=$ac_cv_prog_WINDMC
8031 if test -n "$WINDMC"; then
8032   echo "$as_me:$LINENO: result: $WINDMC" >&5
8033 echo "${ECHO_T}$WINDMC" >&6
8034 else
8035   echo "$as_me:$LINENO: result: no" >&5
8036 echo "${ECHO_T}no" >&6
8037 fi
8038
8039   done
8040 fi
8041
8042 for ncn_progname in windmc; do
8043   if test -n "$ncn_tool_prefix"; then
8044     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8045 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8046 echo "$as_me:$LINENO: checking for $ac_word" >&5
8047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8048 if test "${ac_cv_prog_WINDMC+set}" = set; then
8049   echo $ECHO_N "(cached) $ECHO_C" >&6
8050 else
8051   if test -n "$WINDMC"; then
8052   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8053 else
8054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8055 for as_dir in $PATH
8056 do
8057   IFS=$as_save_IFS
8058   test -z "$as_dir" && as_dir=.
8059   for ac_exec_ext in '' $ac_executable_extensions; do
8060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8061     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8063     break 2
8064   fi
8065 done
8066 done
8067
8068 fi
8069 fi
8070 WINDMC=$ac_cv_prog_WINDMC
8071 if test -n "$WINDMC"; then
8072   echo "$as_me:$LINENO: result: $WINDMC" >&5
8073 echo "${ECHO_T}$WINDMC" >&6
8074 else
8075   echo "$as_me:$LINENO: result: no" >&5
8076 echo "${ECHO_T}no" >&6
8077 fi
8078
8079   fi
8080   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8081     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8082 set dummy ${ncn_progname}; ac_word=$2
8083 echo "$as_me:$LINENO: checking for $ac_word" >&5
8084 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8085 if test "${ac_cv_prog_WINDMC+set}" = set; then
8086   echo $ECHO_N "(cached) $ECHO_C" >&6
8087 else
8088   if test -n "$WINDMC"; then
8089   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8090 else
8091 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8092 for as_dir in $PATH
8093 do
8094   IFS=$as_save_IFS
8095   test -z "$as_dir" && as_dir=.
8096   for ac_exec_ext in '' $ac_executable_extensions; do
8097   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8098     ac_cv_prog_WINDMC="${ncn_progname}"
8099     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8100     break 2
8101   fi
8102 done
8103 done
8104
8105 fi
8106 fi
8107 WINDMC=$ac_cv_prog_WINDMC
8108 if test -n "$WINDMC"; then
8109   echo "$as_me:$LINENO: result: $WINDMC" >&5
8110 echo "${ECHO_T}$WINDMC" >&6
8111 else
8112   echo "$as_me:$LINENO: result: no" >&5
8113 echo "${ECHO_T}no" >&6
8114 fi
8115
8116   fi
8117   test -n "$ac_cv_prog_WINDMC" && break
8118 done
8119
8120 if test -z "$ac_cv_prog_WINDMC" ; then
8121   set dummy windmc
8122   if test $build = $host ; then
8123     WINDMC="$2"
8124   else
8125     WINDMC="${ncn_tool_prefix}$2"
8126   fi
8127 fi
8128
8129
8130
8131 if test -n "$OBJCOPY"; then
8132   ac_cv_prog_OBJCOPY=$OBJCOPY
8133 elif test -n "$ac_cv_prog_OBJCOPY"; then
8134   OBJCOPY=$ac_cv_prog_OBJCOPY
8135 fi
8136
8137 if test -n "$ac_cv_prog_OBJCOPY"; then
8138   for ncn_progname in objcopy; do
8139     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8140 set dummy ${ncn_progname}; ac_word=$2
8141 echo "$as_me:$LINENO: checking for $ac_word" >&5
8142 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8143 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8144   echo $ECHO_N "(cached) $ECHO_C" >&6
8145 else
8146   if test -n "$OBJCOPY"; then
8147   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8148 else
8149 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8150 for as_dir in $PATH
8151 do
8152   IFS=$as_save_IFS
8153   test -z "$as_dir" && as_dir=.
8154   for ac_exec_ext in '' $ac_executable_extensions; do
8155   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8156     ac_cv_prog_OBJCOPY="${ncn_progname}"
8157     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8158     break 2
8159   fi
8160 done
8161 done
8162
8163 fi
8164 fi
8165 OBJCOPY=$ac_cv_prog_OBJCOPY
8166 if test -n "$OBJCOPY"; then
8167   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8168 echo "${ECHO_T}$OBJCOPY" >&6
8169 else
8170   echo "$as_me:$LINENO: result: no" >&5
8171 echo "${ECHO_T}no" >&6
8172 fi
8173
8174   done
8175 fi
8176
8177 for ncn_progname in objcopy; do
8178   if test -n "$ncn_tool_prefix"; then
8179     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8180 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8181 echo "$as_me:$LINENO: checking for $ac_word" >&5
8182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8183 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8184   echo $ECHO_N "(cached) $ECHO_C" >&6
8185 else
8186   if test -n "$OBJCOPY"; then
8187   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8188 else
8189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8190 for as_dir in $PATH
8191 do
8192   IFS=$as_save_IFS
8193   test -z "$as_dir" && as_dir=.
8194   for ac_exec_ext in '' $ac_executable_extensions; do
8195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8196     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8198     break 2
8199   fi
8200 done
8201 done
8202
8203 fi
8204 fi
8205 OBJCOPY=$ac_cv_prog_OBJCOPY
8206 if test -n "$OBJCOPY"; then
8207   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8208 echo "${ECHO_T}$OBJCOPY" >&6
8209 else
8210   echo "$as_me:$LINENO: result: no" >&5
8211 echo "${ECHO_T}no" >&6
8212 fi
8213
8214   fi
8215   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8216     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8217 set dummy ${ncn_progname}; ac_word=$2
8218 echo "$as_me:$LINENO: checking for $ac_word" >&5
8219 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8220 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8221   echo $ECHO_N "(cached) $ECHO_C" >&6
8222 else
8223   if test -n "$OBJCOPY"; then
8224   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8225 else
8226 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8227 for as_dir in $PATH
8228 do
8229   IFS=$as_save_IFS
8230   test -z "$as_dir" && as_dir=.
8231   for ac_exec_ext in '' $ac_executable_extensions; do
8232   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8233     ac_cv_prog_OBJCOPY="${ncn_progname}"
8234     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8235     break 2
8236   fi
8237 done
8238 done
8239
8240 fi
8241 fi
8242 OBJCOPY=$ac_cv_prog_OBJCOPY
8243 if test -n "$OBJCOPY"; then
8244   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8245 echo "${ECHO_T}$OBJCOPY" >&6
8246 else
8247   echo "$as_me:$LINENO: result: no" >&5
8248 echo "${ECHO_T}no" >&6
8249 fi
8250
8251   fi
8252   test -n "$ac_cv_prog_OBJCOPY" && break
8253 done
8254
8255 if test -z "$ac_cv_prog_OBJCOPY" ; then
8256   set dummy objcopy
8257   if test $build = $host ; then
8258     OBJCOPY="$2"
8259   else
8260     OBJCOPY="${ncn_tool_prefix}$2"
8261   fi
8262 fi
8263
8264
8265
8266 if test -n "$OBJDUMP"; then
8267   ac_cv_prog_OBJDUMP=$OBJDUMP
8268 elif test -n "$ac_cv_prog_OBJDUMP"; then
8269   OBJDUMP=$ac_cv_prog_OBJDUMP
8270 fi
8271
8272 if test -n "$ac_cv_prog_OBJDUMP"; then
8273   for ncn_progname in objdump; do
8274     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8275 set dummy ${ncn_progname}; ac_word=$2
8276 echo "$as_me:$LINENO: checking for $ac_word" >&5
8277 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8278 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8279   echo $ECHO_N "(cached) $ECHO_C" >&6
8280 else
8281   if test -n "$OBJDUMP"; then
8282   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8283 else
8284 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8285 for as_dir in $PATH
8286 do
8287   IFS=$as_save_IFS
8288   test -z "$as_dir" && as_dir=.
8289   for ac_exec_ext in '' $ac_executable_extensions; do
8290   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8291     ac_cv_prog_OBJDUMP="${ncn_progname}"
8292     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8293     break 2
8294   fi
8295 done
8296 done
8297
8298 fi
8299 fi
8300 OBJDUMP=$ac_cv_prog_OBJDUMP
8301 if test -n "$OBJDUMP"; then
8302   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8303 echo "${ECHO_T}$OBJDUMP" >&6
8304 else
8305   echo "$as_me:$LINENO: result: no" >&5
8306 echo "${ECHO_T}no" >&6
8307 fi
8308
8309   done
8310 fi
8311
8312 for ncn_progname in objdump; do
8313   if test -n "$ncn_tool_prefix"; then
8314     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8315 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8316 echo "$as_me:$LINENO: checking for $ac_word" >&5
8317 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8318 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8319   echo $ECHO_N "(cached) $ECHO_C" >&6
8320 else
8321   if test -n "$OBJDUMP"; then
8322   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8323 else
8324 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8325 for as_dir in $PATH
8326 do
8327   IFS=$as_save_IFS
8328   test -z "$as_dir" && as_dir=.
8329   for ac_exec_ext in '' $ac_executable_extensions; do
8330   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8331     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8332     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8333     break 2
8334   fi
8335 done
8336 done
8337
8338 fi
8339 fi
8340 OBJDUMP=$ac_cv_prog_OBJDUMP
8341 if test -n "$OBJDUMP"; then
8342   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8343 echo "${ECHO_T}$OBJDUMP" >&6
8344 else
8345   echo "$as_me:$LINENO: result: no" >&5
8346 echo "${ECHO_T}no" >&6
8347 fi
8348
8349   fi
8350   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8351     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8352 set dummy ${ncn_progname}; ac_word=$2
8353 echo "$as_me:$LINENO: checking for $ac_word" >&5
8354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8355 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8356   echo $ECHO_N "(cached) $ECHO_C" >&6
8357 else
8358   if test -n "$OBJDUMP"; then
8359   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8360 else
8361 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8362 for as_dir in $PATH
8363 do
8364   IFS=$as_save_IFS
8365   test -z "$as_dir" && as_dir=.
8366   for ac_exec_ext in '' $ac_executable_extensions; do
8367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8368     ac_cv_prog_OBJDUMP="${ncn_progname}"
8369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8370     break 2
8371   fi
8372 done
8373 done
8374
8375 fi
8376 fi
8377 OBJDUMP=$ac_cv_prog_OBJDUMP
8378 if test -n "$OBJDUMP"; then
8379   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8380 echo "${ECHO_T}$OBJDUMP" >&6
8381 else
8382   echo "$as_me:$LINENO: result: no" >&5
8383 echo "${ECHO_T}no" >&6
8384 fi
8385
8386   fi
8387   test -n "$ac_cv_prog_OBJDUMP" && break
8388 done
8389
8390 if test -z "$ac_cv_prog_OBJDUMP" ; then
8391   set dummy objdump
8392   if test $build = $host ; then
8393     OBJDUMP="$2"
8394   else
8395     OBJDUMP="${ncn_tool_prefix}$2"
8396   fi
8397 fi
8398
8399
8400
8401
8402
8403
8404 # Target tools.
8405
8406 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8407 if test "${with_build_time_tools+set}" = set; then
8408   withval="$with_build_time_tools"
8409   case x"$withval" in
8410      x/*) ;;
8411      *)
8412        with_build_time_tools=
8413        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8414 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8415        ;;
8416    esac
8417 else
8418   with_build_time_tools=
8419 fi;
8420
8421
8422
8423 if test -n "$CC_FOR_TARGET"; then
8424   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8425 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8426   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8427 fi
8428
8429 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8430   for ncn_progname in cc gcc; do
8431     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8432 set dummy ${ncn_progname}; ac_word=$2
8433 echo "$as_me:$LINENO: checking for $ac_word" >&5
8434 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8435 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8436   echo $ECHO_N "(cached) $ECHO_C" >&6
8437 else
8438   if test -n "$CC_FOR_TARGET"; then
8439   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8440 else
8441 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8442 for as_dir in $PATH
8443 do
8444   IFS=$as_save_IFS
8445   test -z "$as_dir" && as_dir=.
8446   for ac_exec_ext in '' $ac_executable_extensions; do
8447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8448     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8450     break 2
8451   fi
8452 done
8453 done
8454
8455 fi
8456 fi
8457 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8458 if test -n "$CC_FOR_TARGET"; then
8459   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8460 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8461 else
8462   echo "$as_me:$LINENO: result: no" >&5
8463 echo "${ECHO_T}no" >&6
8464 fi
8465
8466   done
8467 fi
8468
8469 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8470   for ncn_progname in cc gcc; do
8471     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8472 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8473     if test -x $with_build_time_tools/${ncn_progname}; then
8474       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8475       echo "$as_me:$LINENO: result: yes" >&5
8476 echo "${ECHO_T}yes" >&6
8477       break
8478     else
8479       echo "$as_me:$LINENO: result: no" >&5
8480 echo "${ECHO_T}no" >&6
8481     fi
8482   done
8483 fi
8484
8485 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8486   for ncn_progname in cc gcc; do
8487     if test -n "$ncn_target_tool_prefix"; then
8488       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8489 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8490 echo "$as_me:$LINENO: checking for $ac_word" >&5
8491 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8492 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8493   echo $ECHO_N "(cached) $ECHO_C" >&6
8494 else
8495   if test -n "$CC_FOR_TARGET"; then
8496   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8497 else
8498 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8499 for as_dir in $PATH
8500 do
8501   IFS=$as_save_IFS
8502   test -z "$as_dir" && as_dir=.
8503   for ac_exec_ext in '' $ac_executable_extensions; do
8504   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8505     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8506     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8507     break 2
8508   fi
8509 done
8510 done
8511
8512 fi
8513 fi
8514 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8515 if test -n "$CC_FOR_TARGET"; then
8516   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8517 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8518 else
8519   echo "$as_me:$LINENO: result: no" >&5
8520 echo "${ECHO_T}no" >&6
8521 fi
8522
8523     fi
8524     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8525       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8526 set dummy ${ncn_progname}; ac_word=$2
8527 echo "$as_me:$LINENO: checking for $ac_word" >&5
8528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8529 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8530   echo $ECHO_N "(cached) $ECHO_C" >&6
8531 else
8532   if test -n "$CC_FOR_TARGET"; then
8533   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8534 else
8535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8536 for as_dir in $PATH
8537 do
8538   IFS=$as_save_IFS
8539   test -z "$as_dir" && as_dir=.
8540   for ac_exec_ext in '' $ac_executable_extensions; do
8541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8542     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8544     break 2
8545   fi
8546 done
8547 done
8548
8549 fi
8550 fi
8551 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8552 if test -n "$CC_FOR_TARGET"; then
8553   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8554 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8555 else
8556   echo "$as_me:$LINENO: result: no" >&5
8557 echo "${ECHO_T}no" >&6
8558 fi
8559
8560     fi
8561     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8562   done
8563 fi
8564
8565 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8566   set dummy cc gcc
8567   if test $build = $target ; then
8568     CC_FOR_TARGET="$2"
8569   else
8570     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8571   fi
8572 else
8573   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8574 fi
8575
8576
8577
8578 if test -n "$CXX_FOR_TARGET"; then
8579   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8580 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8581   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8582 fi
8583
8584 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8585   for ncn_progname in c++ g++ cxx gxx; do
8586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8587 set dummy ${ncn_progname}; ac_word=$2
8588 echo "$as_me:$LINENO: checking for $ac_word" >&5
8589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8590 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8591   echo $ECHO_N "(cached) $ECHO_C" >&6
8592 else
8593   if test -n "$CXX_FOR_TARGET"; then
8594   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8595 else
8596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8597 for as_dir in $PATH
8598 do
8599   IFS=$as_save_IFS
8600   test -z "$as_dir" && as_dir=.
8601   for ac_exec_ext in '' $ac_executable_extensions; do
8602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8603     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8605     break 2
8606   fi
8607 done
8608 done
8609
8610 fi
8611 fi
8612 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8613 if test -n "$CXX_FOR_TARGET"; then
8614   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8615 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8616 else
8617   echo "$as_me:$LINENO: result: no" >&5
8618 echo "${ECHO_T}no" >&6
8619 fi
8620
8621   done
8622 fi
8623
8624 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8625   for ncn_progname in c++ g++ cxx gxx; do
8626     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8627 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8628     if test -x $with_build_time_tools/${ncn_progname}; then
8629       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8630       echo "$as_me:$LINENO: result: yes" >&5
8631 echo "${ECHO_T}yes" >&6
8632       break
8633     else
8634       echo "$as_me:$LINENO: result: no" >&5
8635 echo "${ECHO_T}no" >&6
8636     fi
8637   done
8638 fi
8639
8640 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8641   for ncn_progname in c++ g++ cxx gxx; do
8642     if test -n "$ncn_target_tool_prefix"; then
8643       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8644 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8645 echo "$as_me:$LINENO: checking for $ac_word" >&5
8646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8647 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8648   echo $ECHO_N "(cached) $ECHO_C" >&6
8649 else
8650   if test -n "$CXX_FOR_TARGET"; then
8651   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8652 else
8653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8654 for as_dir in $PATH
8655 do
8656   IFS=$as_save_IFS
8657   test -z "$as_dir" && as_dir=.
8658   for ac_exec_ext in '' $ac_executable_extensions; do
8659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8660     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8662     break 2
8663   fi
8664 done
8665 done
8666
8667 fi
8668 fi
8669 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8670 if test -n "$CXX_FOR_TARGET"; then
8671   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8672 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8673 else
8674   echo "$as_me:$LINENO: result: no" >&5
8675 echo "${ECHO_T}no" >&6
8676 fi
8677
8678     fi
8679     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8680       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8681 set dummy ${ncn_progname}; ac_word=$2
8682 echo "$as_me:$LINENO: checking for $ac_word" >&5
8683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8684 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8685   echo $ECHO_N "(cached) $ECHO_C" >&6
8686 else
8687   if test -n "$CXX_FOR_TARGET"; then
8688   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8689 else
8690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8691 for as_dir in $PATH
8692 do
8693   IFS=$as_save_IFS
8694   test -z "$as_dir" && as_dir=.
8695   for ac_exec_ext in '' $ac_executable_extensions; do
8696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8697     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8699     break 2
8700   fi
8701 done
8702 done
8703
8704 fi
8705 fi
8706 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8707 if test -n "$CXX_FOR_TARGET"; then
8708   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8709 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8710 else
8711   echo "$as_me:$LINENO: result: no" >&5
8712 echo "${ECHO_T}no" >&6
8713 fi
8714
8715     fi
8716     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8717   done
8718 fi
8719
8720 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8721   set dummy c++ g++ cxx gxx
8722   if test $build = $target ; then
8723     CXX_FOR_TARGET="$2"
8724   else
8725     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8726   fi
8727 else
8728   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8729 fi
8730
8731
8732
8733 if test -n "$GCC_FOR_TARGET"; then
8734   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8735 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8736   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8737 fi
8738
8739 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8740   for ncn_progname in gcc; do
8741     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8742 set dummy ${ncn_progname}; ac_word=$2
8743 echo "$as_me:$LINENO: checking for $ac_word" >&5
8744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8745 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8746   echo $ECHO_N "(cached) $ECHO_C" >&6
8747 else
8748   if test -n "$GCC_FOR_TARGET"; then
8749   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8750 else
8751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8752 for as_dir in $PATH
8753 do
8754   IFS=$as_save_IFS
8755   test -z "$as_dir" && as_dir=.
8756   for ac_exec_ext in '' $ac_executable_extensions; do
8757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8758     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8760     break 2
8761   fi
8762 done
8763 done
8764
8765 fi
8766 fi
8767 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8768 if test -n "$GCC_FOR_TARGET"; then
8769   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8770 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8771 else
8772   echo "$as_me:$LINENO: result: no" >&5
8773 echo "${ECHO_T}no" >&6
8774 fi
8775
8776   done
8777 fi
8778
8779 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8780   for ncn_progname in gcc; do
8781     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8782 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8783     if test -x $with_build_time_tools/${ncn_progname}; then
8784       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8785       echo "$as_me:$LINENO: result: yes" >&5
8786 echo "${ECHO_T}yes" >&6
8787       break
8788     else
8789       echo "$as_me:$LINENO: result: no" >&5
8790 echo "${ECHO_T}no" >&6
8791     fi
8792   done
8793 fi
8794
8795 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8796   for ncn_progname in gcc; do
8797     if test -n "$ncn_target_tool_prefix"; then
8798       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8799 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8800 echo "$as_me:$LINENO: checking for $ac_word" >&5
8801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8802 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8803   echo $ECHO_N "(cached) $ECHO_C" >&6
8804 else
8805   if test -n "$GCC_FOR_TARGET"; then
8806   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8807 else
8808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8809 for as_dir in $PATH
8810 do
8811   IFS=$as_save_IFS
8812   test -z "$as_dir" && as_dir=.
8813   for ac_exec_ext in '' $ac_executable_extensions; do
8814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8815     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8817     break 2
8818   fi
8819 done
8820 done
8821
8822 fi
8823 fi
8824 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8825 if test -n "$GCC_FOR_TARGET"; then
8826   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8827 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8828 else
8829   echo "$as_me:$LINENO: result: no" >&5
8830 echo "${ECHO_T}no" >&6
8831 fi
8832
8833     fi
8834     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8835       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8836 set dummy ${ncn_progname}; ac_word=$2
8837 echo "$as_me:$LINENO: checking for $ac_word" >&5
8838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8839 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8840   echo $ECHO_N "(cached) $ECHO_C" >&6
8841 else
8842   if test -n "$GCC_FOR_TARGET"; then
8843   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8844 else
8845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8846 for as_dir in $PATH
8847 do
8848   IFS=$as_save_IFS
8849   test -z "$as_dir" && as_dir=.
8850   for ac_exec_ext in '' $ac_executable_extensions; do
8851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8852     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8854     break 2
8855   fi
8856 done
8857 done
8858
8859 fi
8860 fi
8861 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8862 if test -n "$GCC_FOR_TARGET"; then
8863   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8864 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8865 else
8866   echo "$as_me:$LINENO: result: no" >&5
8867 echo "${ECHO_T}no" >&6
8868 fi
8869
8870     fi
8871     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8872   done
8873 fi
8874
8875 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8876   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8877 else
8878   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8879 fi
8880
8881
8882
8883 if test -n "$GCJ_FOR_TARGET"; then
8884   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8885 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8886   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8887 fi
8888
8889 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8890   for ncn_progname in gcj; do
8891     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8892 set dummy ${ncn_progname}; ac_word=$2
8893 echo "$as_me:$LINENO: checking for $ac_word" >&5
8894 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8895 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8896   echo $ECHO_N "(cached) $ECHO_C" >&6
8897 else
8898   if test -n "$GCJ_FOR_TARGET"; then
8899   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8900 else
8901 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8902 for as_dir in $PATH
8903 do
8904   IFS=$as_save_IFS
8905   test -z "$as_dir" && as_dir=.
8906   for ac_exec_ext in '' $ac_executable_extensions; do
8907   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8908     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8909     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8910     break 2
8911   fi
8912 done
8913 done
8914
8915 fi
8916 fi
8917 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8918 if test -n "$GCJ_FOR_TARGET"; then
8919   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8920 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8921 else
8922   echo "$as_me:$LINENO: result: no" >&5
8923 echo "${ECHO_T}no" >&6
8924 fi
8925
8926   done
8927 fi
8928
8929 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8930   for ncn_progname in gcj; do
8931     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8932 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8933     if test -x $with_build_time_tools/${ncn_progname}; then
8934       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8935       echo "$as_me:$LINENO: result: yes" >&5
8936 echo "${ECHO_T}yes" >&6
8937       break
8938     else
8939       echo "$as_me:$LINENO: result: no" >&5
8940 echo "${ECHO_T}no" >&6
8941     fi
8942   done
8943 fi
8944
8945 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8946   for ncn_progname in gcj; do
8947     if test -n "$ncn_target_tool_prefix"; then
8948       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8949 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8950 echo "$as_me:$LINENO: checking for $ac_word" >&5
8951 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8952 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8953   echo $ECHO_N "(cached) $ECHO_C" >&6
8954 else
8955   if test -n "$GCJ_FOR_TARGET"; then
8956   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8957 else
8958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8959 for as_dir in $PATH
8960 do
8961   IFS=$as_save_IFS
8962   test -z "$as_dir" && as_dir=.
8963   for ac_exec_ext in '' $ac_executable_extensions; do
8964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8965     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8967     break 2
8968   fi
8969 done
8970 done
8971
8972 fi
8973 fi
8974 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8975 if test -n "$GCJ_FOR_TARGET"; then
8976   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8977 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8978 else
8979   echo "$as_me:$LINENO: result: no" >&5
8980 echo "${ECHO_T}no" >&6
8981 fi
8982
8983     fi
8984     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8985       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8986 set dummy ${ncn_progname}; ac_word=$2
8987 echo "$as_me:$LINENO: checking for $ac_word" >&5
8988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8989 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8990   echo $ECHO_N "(cached) $ECHO_C" >&6
8991 else
8992   if test -n "$GCJ_FOR_TARGET"; then
8993   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8994 else
8995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8996 for as_dir in $PATH
8997 do
8998   IFS=$as_save_IFS
8999   test -z "$as_dir" && as_dir=.
9000   for ac_exec_ext in '' $ac_executable_extensions; do
9001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9002     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
9003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9004     break 2
9005   fi
9006 done
9007 done
9008
9009 fi
9010 fi
9011 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
9012 if test -n "$GCJ_FOR_TARGET"; then
9013   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
9014 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
9015 else
9016   echo "$as_me:$LINENO: result: no" >&5
9017 echo "${ECHO_T}no" >&6
9018 fi
9019
9020     fi
9021     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9022   done
9023 fi
9024
9025 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9026   set dummy gcj
9027   if test $build = $target ; then
9028     GCJ_FOR_TARGET="$2"
9029   else
9030     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9031   fi
9032 else
9033   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9034 fi
9035
9036
9037
9038 if test -n "$GFORTRAN_FOR_TARGET"; then
9039   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9040 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9041   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9042 fi
9043
9044 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9045   for ncn_progname in gfortran; do
9046     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9047 set dummy ${ncn_progname}; ac_word=$2
9048 echo "$as_me:$LINENO: checking for $ac_word" >&5
9049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9050 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9051   echo $ECHO_N "(cached) $ECHO_C" >&6
9052 else
9053   if test -n "$GFORTRAN_FOR_TARGET"; then
9054   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9055 else
9056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9057 for as_dir in $PATH
9058 do
9059   IFS=$as_save_IFS
9060   test -z "$as_dir" && as_dir=.
9061   for ac_exec_ext in '' $ac_executable_extensions; do
9062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9063     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9065     break 2
9066   fi
9067 done
9068 done
9069
9070 fi
9071 fi
9072 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9073 if test -n "$GFORTRAN_FOR_TARGET"; then
9074   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9075 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9076 else
9077   echo "$as_me:$LINENO: result: no" >&5
9078 echo "${ECHO_T}no" >&6
9079 fi
9080
9081   done
9082 fi
9083
9084 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9085   for ncn_progname in gfortran; do
9086     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9087 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9088     if test -x $with_build_time_tools/${ncn_progname}; then
9089       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9090       echo "$as_me:$LINENO: result: yes" >&5
9091 echo "${ECHO_T}yes" >&6
9092       break
9093     else
9094       echo "$as_me:$LINENO: result: no" >&5
9095 echo "${ECHO_T}no" >&6
9096     fi
9097   done
9098 fi
9099
9100 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9101   for ncn_progname in gfortran; do
9102     if test -n "$ncn_target_tool_prefix"; then
9103       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9104 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9105 echo "$as_me:$LINENO: checking for $ac_word" >&5
9106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9107 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9108   echo $ECHO_N "(cached) $ECHO_C" >&6
9109 else
9110   if test -n "$GFORTRAN_FOR_TARGET"; then
9111   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9112 else
9113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9114 for as_dir in $PATH
9115 do
9116   IFS=$as_save_IFS
9117   test -z "$as_dir" && as_dir=.
9118   for ac_exec_ext in '' $ac_executable_extensions; do
9119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9120     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9121     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9122     break 2
9123   fi
9124 done
9125 done
9126
9127 fi
9128 fi
9129 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9130 if test -n "$GFORTRAN_FOR_TARGET"; then
9131   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9132 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9133 else
9134   echo "$as_me:$LINENO: result: no" >&5
9135 echo "${ECHO_T}no" >&6
9136 fi
9137
9138     fi
9139     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9140       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9141 set dummy ${ncn_progname}; ac_word=$2
9142 echo "$as_me:$LINENO: checking for $ac_word" >&5
9143 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9144 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9145   echo $ECHO_N "(cached) $ECHO_C" >&6
9146 else
9147   if test -n "$GFORTRAN_FOR_TARGET"; then
9148   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9149 else
9150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9151 for as_dir in $PATH
9152 do
9153   IFS=$as_save_IFS
9154   test -z "$as_dir" && as_dir=.
9155   for ac_exec_ext in '' $ac_executable_extensions; do
9156   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9157     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9158     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9159     break 2
9160   fi
9161 done
9162 done
9163
9164 fi
9165 fi
9166 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9167 if test -n "$GFORTRAN_FOR_TARGET"; then
9168   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9169 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9170 else
9171   echo "$as_me:$LINENO: result: no" >&5
9172 echo "${ECHO_T}no" >&6
9173 fi
9174
9175     fi
9176     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9177   done
9178 fi
9179
9180 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9181   set dummy gfortran
9182   if test $build = $target ; then
9183     GFORTRAN_FOR_TARGET="$2"
9184   else
9185     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9186   fi
9187 else
9188   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9189 fi
9190
9191
9192
9193 cat > conftest.c << \EOF
9194 #ifdef __GNUC__
9195   gcc_yay;
9196 #endif
9197 EOF
9198 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9199   have_gcc_for_target=yes
9200 else
9201   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9202   have_gcc_for_target=no
9203 fi
9204 rm conftest.c
9205
9206
9207
9208
9209 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9210   if test -n "$with_build_time_tools"; then
9211     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9212 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9213     if test -x $with_build_time_tools/ar; then
9214       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9215       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9216       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9217 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9218     else
9219       echo "$as_me:$LINENO: result: no" >&5
9220 echo "${ECHO_T}no" >&6
9221     fi
9222   elif test $build != $host && test $have_gcc_for_target = yes; then
9223     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9224     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9225     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9226   fi
9227 fi
9228 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9229   # Extract the first word of "ar", so it can be a program name with args.
9230 set dummy ar; ac_word=$2
9231 echo "$as_me:$LINENO: checking for $ac_word" >&5
9232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9233 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9234   echo $ECHO_N "(cached) $ECHO_C" >&6
9235 else
9236   case $AR_FOR_TARGET in
9237   [\\/]* | ?:[\\/]*)
9238   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9239   ;;
9240   *)
9241   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9242 for as_dir in $gcc_cv_tool_dirs
9243 do
9244   IFS=$as_save_IFS
9245   test -z "$as_dir" && as_dir=.
9246   for ac_exec_ext in '' $ac_executable_extensions; do
9247   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9248     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9249     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9250     break 2
9251   fi
9252 done
9253 done
9254
9255   ;;
9256 esac
9257 fi
9258 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9259
9260 if test -n "$AR_FOR_TARGET"; then
9261   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9262 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9263 else
9264   echo "$as_me:$LINENO: result: no" >&5
9265 echo "${ECHO_T}no" >&6
9266 fi
9267
9268 fi
9269 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9270
9271
9272 if test -n "$AR_FOR_TARGET"; then
9273   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9274 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9275   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9276 fi
9277
9278 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9279   for ncn_progname in ar; do
9280     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9281 set dummy ${ncn_progname}; ac_word=$2
9282 echo "$as_me:$LINENO: checking for $ac_word" >&5
9283 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9284 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9285   echo $ECHO_N "(cached) $ECHO_C" >&6
9286 else
9287   if test -n "$AR_FOR_TARGET"; then
9288   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9289 else
9290 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9291 for as_dir in $PATH
9292 do
9293   IFS=$as_save_IFS
9294   test -z "$as_dir" && as_dir=.
9295   for ac_exec_ext in '' $ac_executable_extensions; do
9296   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9297     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9298     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9299     break 2
9300   fi
9301 done
9302 done
9303
9304 fi
9305 fi
9306 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9307 if test -n "$AR_FOR_TARGET"; then
9308   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9309 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9310 else
9311   echo "$as_me:$LINENO: result: no" >&5
9312 echo "${ECHO_T}no" >&6
9313 fi
9314
9315   done
9316 fi
9317
9318 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9319   for ncn_progname in ar; do
9320     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9321 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9322     if test -x $with_build_time_tools/${ncn_progname}; then
9323       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9324       echo "$as_me:$LINENO: result: yes" >&5
9325 echo "${ECHO_T}yes" >&6
9326       break
9327     else
9328       echo "$as_me:$LINENO: result: no" >&5
9329 echo "${ECHO_T}no" >&6
9330     fi
9331   done
9332 fi
9333
9334 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9335   for ncn_progname in ar; do
9336     if test -n "$ncn_target_tool_prefix"; then
9337       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9338 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9339 echo "$as_me:$LINENO: checking for $ac_word" >&5
9340 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9341 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9342   echo $ECHO_N "(cached) $ECHO_C" >&6
9343 else
9344   if test -n "$AR_FOR_TARGET"; then
9345   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9346 else
9347 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9348 for as_dir in $PATH
9349 do
9350   IFS=$as_save_IFS
9351   test -z "$as_dir" && as_dir=.
9352   for ac_exec_ext in '' $ac_executable_extensions; do
9353   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9354     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9355     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9356     break 2
9357   fi
9358 done
9359 done
9360
9361 fi
9362 fi
9363 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9364 if test -n "$AR_FOR_TARGET"; then
9365   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9366 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9367 else
9368   echo "$as_me:$LINENO: result: no" >&5
9369 echo "${ECHO_T}no" >&6
9370 fi
9371
9372     fi
9373     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9374       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9375 set dummy ${ncn_progname}; ac_word=$2
9376 echo "$as_me:$LINENO: checking for $ac_word" >&5
9377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9378 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9379   echo $ECHO_N "(cached) $ECHO_C" >&6
9380 else
9381   if test -n "$AR_FOR_TARGET"; then
9382   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9383 else
9384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9385 for as_dir in $PATH
9386 do
9387   IFS=$as_save_IFS
9388   test -z "$as_dir" && as_dir=.
9389   for ac_exec_ext in '' $ac_executable_extensions; do
9390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9391     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9393     break 2
9394   fi
9395 done
9396 done
9397
9398 fi
9399 fi
9400 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9401 if test -n "$AR_FOR_TARGET"; then
9402   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9403 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9404 else
9405   echo "$as_me:$LINENO: result: no" >&5
9406 echo "${ECHO_T}no" >&6
9407 fi
9408
9409     fi
9410     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9411   done
9412 fi
9413
9414 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9415   set dummy ar
9416   if test $build = $target ; then
9417     AR_FOR_TARGET="$2"
9418   else
9419     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9420   fi
9421 else
9422   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9423 fi
9424
9425 else
9426   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9427 fi
9428
9429
9430
9431
9432 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9433   if test -n "$with_build_time_tools"; then
9434     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9435 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9436     if test -x $with_build_time_tools/as; then
9437       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9438       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9439       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9440 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9441     else
9442       echo "$as_me:$LINENO: result: no" >&5
9443 echo "${ECHO_T}no" >&6
9444     fi
9445   elif test $build != $host && test $have_gcc_for_target = yes; then
9446     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9447     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9448     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9449   fi
9450 fi
9451 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9452   # Extract the first word of "as", so it can be a program name with args.
9453 set dummy as; ac_word=$2
9454 echo "$as_me:$LINENO: checking for $ac_word" >&5
9455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9456 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9457   echo $ECHO_N "(cached) $ECHO_C" >&6
9458 else
9459   case $AS_FOR_TARGET in
9460   [\\/]* | ?:[\\/]*)
9461   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9462   ;;
9463   *)
9464   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9465 for as_dir in $gcc_cv_tool_dirs
9466 do
9467   IFS=$as_save_IFS
9468   test -z "$as_dir" && as_dir=.
9469   for ac_exec_ext in '' $ac_executable_extensions; do
9470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9471     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9473     break 2
9474   fi
9475 done
9476 done
9477
9478   ;;
9479 esac
9480 fi
9481 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9482
9483 if test -n "$AS_FOR_TARGET"; then
9484   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9485 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9486 else
9487   echo "$as_me:$LINENO: result: no" >&5
9488 echo "${ECHO_T}no" >&6
9489 fi
9490
9491 fi
9492 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9493
9494
9495 if test -n "$AS_FOR_TARGET"; then
9496   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9497 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9498   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9499 fi
9500
9501 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9502   for ncn_progname in as; do
9503     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9504 set dummy ${ncn_progname}; ac_word=$2
9505 echo "$as_me:$LINENO: checking for $ac_word" >&5
9506 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9507 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9508   echo $ECHO_N "(cached) $ECHO_C" >&6
9509 else
9510   if test -n "$AS_FOR_TARGET"; then
9511   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9512 else
9513 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9514 for as_dir in $PATH
9515 do
9516   IFS=$as_save_IFS
9517   test -z "$as_dir" && as_dir=.
9518   for ac_exec_ext in '' $ac_executable_extensions; do
9519   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9520     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9521     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9522     break 2
9523   fi
9524 done
9525 done
9526
9527 fi
9528 fi
9529 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9530 if test -n "$AS_FOR_TARGET"; then
9531   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9532 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9533 else
9534   echo "$as_me:$LINENO: result: no" >&5
9535 echo "${ECHO_T}no" >&6
9536 fi
9537
9538   done
9539 fi
9540
9541 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9542   for ncn_progname in as; do
9543     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9544 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9545     if test -x $with_build_time_tools/${ncn_progname}; then
9546       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9547       echo "$as_me:$LINENO: result: yes" >&5
9548 echo "${ECHO_T}yes" >&6
9549       break
9550     else
9551       echo "$as_me:$LINENO: result: no" >&5
9552 echo "${ECHO_T}no" >&6
9553     fi
9554   done
9555 fi
9556
9557 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9558   for ncn_progname in as; do
9559     if test -n "$ncn_target_tool_prefix"; then
9560       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9561 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9562 echo "$as_me:$LINENO: checking for $ac_word" >&5
9563 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9564 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9565   echo $ECHO_N "(cached) $ECHO_C" >&6
9566 else
9567   if test -n "$AS_FOR_TARGET"; then
9568   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9569 else
9570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9571 for as_dir in $PATH
9572 do
9573   IFS=$as_save_IFS
9574   test -z "$as_dir" && as_dir=.
9575   for ac_exec_ext in '' $ac_executable_extensions; do
9576   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9577     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9578     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9579     break 2
9580   fi
9581 done
9582 done
9583
9584 fi
9585 fi
9586 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9587 if test -n "$AS_FOR_TARGET"; then
9588   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9589 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9590 else
9591   echo "$as_me:$LINENO: result: no" >&5
9592 echo "${ECHO_T}no" >&6
9593 fi
9594
9595     fi
9596     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9597       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9598 set dummy ${ncn_progname}; ac_word=$2
9599 echo "$as_me:$LINENO: checking for $ac_word" >&5
9600 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9601 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9602   echo $ECHO_N "(cached) $ECHO_C" >&6
9603 else
9604   if test -n "$AS_FOR_TARGET"; then
9605   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9606 else
9607 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9608 for as_dir in $PATH
9609 do
9610   IFS=$as_save_IFS
9611   test -z "$as_dir" && as_dir=.
9612   for ac_exec_ext in '' $ac_executable_extensions; do
9613   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9614     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9615     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9616     break 2
9617   fi
9618 done
9619 done
9620
9621 fi
9622 fi
9623 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9624 if test -n "$AS_FOR_TARGET"; then
9625   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9626 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9627 else
9628   echo "$as_me:$LINENO: result: no" >&5
9629 echo "${ECHO_T}no" >&6
9630 fi
9631
9632     fi
9633     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9634   done
9635 fi
9636
9637 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9638   set dummy as
9639   if test $build = $target ; then
9640     AS_FOR_TARGET="$2"
9641   else
9642     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9643   fi
9644 else
9645   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9646 fi
9647
9648 else
9649   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9650 fi
9651
9652
9653
9654
9655 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9656   if test -n "$with_build_time_tools"; then
9657     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9658 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9659     if test -x $with_build_time_tools/dlltool; then
9660       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9661       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9662       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9663 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9664     else
9665       echo "$as_me:$LINENO: result: no" >&5
9666 echo "${ECHO_T}no" >&6
9667     fi
9668   elif test $build != $host && test $have_gcc_for_target = yes; then
9669     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9670     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9671     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9672   fi
9673 fi
9674 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9675   # Extract the first word of "dlltool", so it can be a program name with args.
9676 set dummy dlltool; ac_word=$2
9677 echo "$as_me:$LINENO: checking for $ac_word" >&5
9678 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9679 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9680   echo $ECHO_N "(cached) $ECHO_C" >&6
9681 else
9682   case $DLLTOOL_FOR_TARGET in
9683   [\\/]* | ?:[\\/]*)
9684   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9685   ;;
9686   *)
9687   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9688 for as_dir in $gcc_cv_tool_dirs
9689 do
9690   IFS=$as_save_IFS
9691   test -z "$as_dir" && as_dir=.
9692   for ac_exec_ext in '' $ac_executable_extensions; do
9693   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9694     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9695     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9696     break 2
9697   fi
9698 done
9699 done
9700
9701   ;;
9702 esac
9703 fi
9704 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9705
9706 if test -n "$DLLTOOL_FOR_TARGET"; then
9707   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9708 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9709 else
9710   echo "$as_me:$LINENO: result: no" >&5
9711 echo "${ECHO_T}no" >&6
9712 fi
9713
9714 fi
9715 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9716
9717
9718 if test -n "$DLLTOOL_FOR_TARGET"; then
9719   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9720 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9721   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9722 fi
9723
9724 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9725   for ncn_progname in dlltool; do
9726     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9727 set dummy ${ncn_progname}; ac_word=$2
9728 echo "$as_me:$LINENO: checking for $ac_word" >&5
9729 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9730 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9731   echo $ECHO_N "(cached) $ECHO_C" >&6
9732 else
9733   if test -n "$DLLTOOL_FOR_TARGET"; then
9734   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9735 else
9736 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9737 for as_dir in $PATH
9738 do
9739   IFS=$as_save_IFS
9740   test -z "$as_dir" && as_dir=.
9741   for ac_exec_ext in '' $ac_executable_extensions; do
9742   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9743     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9744     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9745     break 2
9746   fi
9747 done
9748 done
9749
9750 fi
9751 fi
9752 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9753 if test -n "$DLLTOOL_FOR_TARGET"; then
9754   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9755 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9756 else
9757   echo "$as_me:$LINENO: result: no" >&5
9758 echo "${ECHO_T}no" >&6
9759 fi
9760
9761   done
9762 fi
9763
9764 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9765   for ncn_progname in dlltool; do
9766     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9767 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9768     if test -x $with_build_time_tools/${ncn_progname}; then
9769       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9770       echo "$as_me:$LINENO: result: yes" >&5
9771 echo "${ECHO_T}yes" >&6
9772       break
9773     else
9774       echo "$as_me:$LINENO: result: no" >&5
9775 echo "${ECHO_T}no" >&6
9776     fi
9777   done
9778 fi
9779
9780 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9781   for ncn_progname in dlltool; do
9782     if test -n "$ncn_target_tool_prefix"; then
9783       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9784 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9785 echo "$as_me:$LINENO: checking for $ac_word" >&5
9786 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9787 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9788   echo $ECHO_N "(cached) $ECHO_C" >&6
9789 else
9790   if test -n "$DLLTOOL_FOR_TARGET"; then
9791   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9792 else
9793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9794 for as_dir in $PATH
9795 do
9796   IFS=$as_save_IFS
9797   test -z "$as_dir" && as_dir=.
9798   for ac_exec_ext in '' $ac_executable_extensions; do
9799   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9800     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9801     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9802     break 2
9803   fi
9804 done
9805 done
9806
9807 fi
9808 fi
9809 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9810 if test -n "$DLLTOOL_FOR_TARGET"; then
9811   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9812 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9813 else
9814   echo "$as_me:$LINENO: result: no" >&5
9815 echo "${ECHO_T}no" >&6
9816 fi
9817
9818     fi
9819     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9820       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9821 set dummy ${ncn_progname}; ac_word=$2
9822 echo "$as_me:$LINENO: checking for $ac_word" >&5
9823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9824 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9825   echo $ECHO_N "(cached) $ECHO_C" >&6
9826 else
9827   if test -n "$DLLTOOL_FOR_TARGET"; then
9828   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9829 else
9830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9831 for as_dir in $PATH
9832 do
9833   IFS=$as_save_IFS
9834   test -z "$as_dir" && as_dir=.
9835   for ac_exec_ext in '' $ac_executable_extensions; do
9836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9837     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9839     break 2
9840   fi
9841 done
9842 done
9843
9844 fi
9845 fi
9846 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9847 if test -n "$DLLTOOL_FOR_TARGET"; then
9848   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9849 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9850 else
9851   echo "$as_me:$LINENO: result: no" >&5
9852 echo "${ECHO_T}no" >&6
9853 fi
9854
9855     fi
9856     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9857   done
9858 fi
9859
9860 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9861   set dummy dlltool
9862   if test $build = $target ; then
9863     DLLTOOL_FOR_TARGET="$2"
9864   else
9865     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9866   fi
9867 else
9868   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9869 fi
9870
9871 else
9872   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9873 fi
9874
9875
9876
9877
9878 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9879   if test -n "$with_build_time_tools"; then
9880     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9881 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9882     if test -x $with_build_time_tools/ld; then
9883       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9884       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9885       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9886 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9887     else
9888       echo "$as_me:$LINENO: result: no" >&5
9889 echo "${ECHO_T}no" >&6
9890     fi
9891   elif test $build != $host && test $have_gcc_for_target = yes; then
9892     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9893     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9894     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9895   fi
9896 fi
9897 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9898   # Extract the first word of "ld", so it can be a program name with args.
9899 set dummy ld; ac_word=$2
9900 echo "$as_me:$LINENO: checking for $ac_word" >&5
9901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9902 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9903   echo $ECHO_N "(cached) $ECHO_C" >&6
9904 else
9905   case $LD_FOR_TARGET in
9906   [\\/]* | ?:[\\/]*)
9907   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9908   ;;
9909   *)
9910   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9911 for as_dir in $gcc_cv_tool_dirs
9912 do
9913   IFS=$as_save_IFS
9914   test -z "$as_dir" && as_dir=.
9915   for ac_exec_ext in '' $ac_executable_extensions; do
9916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9917     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9919     break 2
9920   fi
9921 done
9922 done
9923
9924   ;;
9925 esac
9926 fi
9927 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9928
9929 if test -n "$LD_FOR_TARGET"; then
9930   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9931 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9932 else
9933   echo "$as_me:$LINENO: result: no" >&5
9934 echo "${ECHO_T}no" >&6
9935 fi
9936
9937 fi
9938 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9939
9940
9941 if test -n "$LD_FOR_TARGET"; then
9942   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9943 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9944   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9945 fi
9946
9947 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9948   for ncn_progname in ld; do
9949     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9950 set dummy ${ncn_progname}; ac_word=$2
9951 echo "$as_me:$LINENO: checking for $ac_word" >&5
9952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9953 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9954   echo $ECHO_N "(cached) $ECHO_C" >&6
9955 else
9956   if test -n "$LD_FOR_TARGET"; then
9957   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9958 else
9959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9960 for as_dir in $PATH
9961 do
9962   IFS=$as_save_IFS
9963   test -z "$as_dir" && as_dir=.
9964   for ac_exec_ext in '' $ac_executable_extensions; do
9965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9966     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9968     break 2
9969   fi
9970 done
9971 done
9972
9973 fi
9974 fi
9975 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9976 if test -n "$LD_FOR_TARGET"; then
9977   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9978 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9979 else
9980   echo "$as_me:$LINENO: result: no" >&5
9981 echo "${ECHO_T}no" >&6
9982 fi
9983
9984   done
9985 fi
9986
9987 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9988   for ncn_progname in ld; do
9989     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9990 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9991     if test -x $with_build_time_tools/${ncn_progname}; then
9992       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9993       echo "$as_me:$LINENO: result: yes" >&5
9994 echo "${ECHO_T}yes" >&6
9995       break
9996     else
9997       echo "$as_me:$LINENO: result: no" >&5
9998 echo "${ECHO_T}no" >&6
9999     fi
10000   done
10001 fi
10002
10003 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
10004   for ncn_progname in ld; do
10005     if test -n "$ncn_target_tool_prefix"; then
10006       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10007 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10008 echo "$as_me:$LINENO: checking for $ac_word" >&5
10009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10010 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10011   echo $ECHO_N "(cached) $ECHO_C" >&6
10012 else
10013   if test -n "$LD_FOR_TARGET"; then
10014   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10015 else
10016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10017 for as_dir in $PATH
10018 do
10019   IFS=$as_save_IFS
10020   test -z "$as_dir" && as_dir=.
10021   for ac_exec_ext in '' $ac_executable_extensions; do
10022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10023     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10025     break 2
10026   fi
10027 done
10028 done
10029
10030 fi
10031 fi
10032 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10033 if test -n "$LD_FOR_TARGET"; then
10034   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10035 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10036 else
10037   echo "$as_me:$LINENO: result: no" >&5
10038 echo "${ECHO_T}no" >&6
10039 fi
10040
10041     fi
10042     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10043       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10044 set dummy ${ncn_progname}; ac_word=$2
10045 echo "$as_me:$LINENO: checking for $ac_word" >&5
10046 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10047 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10048   echo $ECHO_N "(cached) $ECHO_C" >&6
10049 else
10050   if test -n "$LD_FOR_TARGET"; then
10051   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10052 else
10053 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10054 for as_dir in $PATH
10055 do
10056   IFS=$as_save_IFS
10057   test -z "$as_dir" && as_dir=.
10058   for ac_exec_ext in '' $ac_executable_extensions; do
10059   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10060     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10061     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10062     break 2
10063   fi
10064 done
10065 done
10066
10067 fi
10068 fi
10069 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10070 if test -n "$LD_FOR_TARGET"; then
10071   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10072 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10073 else
10074   echo "$as_me:$LINENO: result: no" >&5
10075 echo "${ECHO_T}no" >&6
10076 fi
10077
10078     fi
10079     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10080   done
10081 fi
10082
10083 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10084   set dummy ld
10085   if test $build = $target ; then
10086     LD_FOR_TARGET="$2"
10087   else
10088     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10089   fi
10090 else
10091   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10092 fi
10093
10094 else
10095   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10096 fi
10097
10098
10099
10100
10101 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10102   if test -n "$with_build_time_tools"; then
10103     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10104 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10105     if test -x $with_build_time_tools/lipo; then
10106       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10107       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10108       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10109 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10110     else
10111       echo "$as_me:$LINENO: result: no" >&5
10112 echo "${ECHO_T}no" >&6
10113     fi
10114   elif test $build != $host && test $have_gcc_for_target = yes; then
10115     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10116     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10117     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10118   fi
10119 fi
10120 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10121   # Extract the first word of "lipo", so it can be a program name with args.
10122 set dummy lipo; ac_word=$2
10123 echo "$as_me:$LINENO: checking for $ac_word" >&5
10124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10125 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10126   echo $ECHO_N "(cached) $ECHO_C" >&6
10127 else
10128   case $LIPO_FOR_TARGET in
10129   [\\/]* | ?:[\\/]*)
10130   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10131   ;;
10132   *)
10133   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10134 for as_dir in $gcc_cv_tool_dirs
10135 do
10136   IFS=$as_save_IFS
10137   test -z "$as_dir" && as_dir=.
10138   for ac_exec_ext in '' $ac_executable_extensions; do
10139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10140     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10142     break 2
10143   fi
10144 done
10145 done
10146
10147   ;;
10148 esac
10149 fi
10150 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10151
10152 if test -n "$LIPO_FOR_TARGET"; then
10153   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10154 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10155 else
10156   echo "$as_me:$LINENO: result: no" >&5
10157 echo "${ECHO_T}no" >&6
10158 fi
10159
10160 fi
10161 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10162
10163
10164 if test -n "$LIPO_FOR_TARGET"; then
10165   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10166 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10167   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10168 fi
10169
10170 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10171   for ncn_progname in lipo; do
10172     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10173 set dummy ${ncn_progname}; ac_word=$2
10174 echo "$as_me:$LINENO: checking for $ac_word" >&5
10175 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10176 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10177   echo $ECHO_N "(cached) $ECHO_C" >&6
10178 else
10179   if test -n "$LIPO_FOR_TARGET"; then
10180   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10181 else
10182 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10183 for as_dir in $PATH
10184 do
10185   IFS=$as_save_IFS
10186   test -z "$as_dir" && as_dir=.
10187   for ac_exec_ext in '' $ac_executable_extensions; do
10188   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10189     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10190     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10191     break 2
10192   fi
10193 done
10194 done
10195
10196 fi
10197 fi
10198 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10199 if test -n "$LIPO_FOR_TARGET"; then
10200   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10201 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10202 else
10203   echo "$as_me:$LINENO: result: no" >&5
10204 echo "${ECHO_T}no" >&6
10205 fi
10206
10207   done
10208 fi
10209
10210 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10211   for ncn_progname in lipo; do
10212     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10213 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10214     if test -x $with_build_time_tools/${ncn_progname}; then
10215       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10216       echo "$as_me:$LINENO: result: yes" >&5
10217 echo "${ECHO_T}yes" >&6
10218       break
10219     else
10220       echo "$as_me:$LINENO: result: no" >&5
10221 echo "${ECHO_T}no" >&6
10222     fi
10223   done
10224 fi
10225
10226 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10227   for ncn_progname in lipo; do
10228     if test -n "$ncn_target_tool_prefix"; then
10229       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10230 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10231 echo "$as_me:$LINENO: checking for $ac_word" >&5
10232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10233 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10234   echo $ECHO_N "(cached) $ECHO_C" >&6
10235 else
10236   if test -n "$LIPO_FOR_TARGET"; then
10237   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10238 else
10239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10240 for as_dir in $PATH
10241 do
10242   IFS=$as_save_IFS
10243   test -z "$as_dir" && as_dir=.
10244   for ac_exec_ext in '' $ac_executable_extensions; do
10245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10246     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10248     break 2
10249   fi
10250 done
10251 done
10252
10253 fi
10254 fi
10255 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10256 if test -n "$LIPO_FOR_TARGET"; then
10257   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10258 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10259 else
10260   echo "$as_me:$LINENO: result: no" >&5
10261 echo "${ECHO_T}no" >&6
10262 fi
10263
10264     fi
10265     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10266       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10267 set dummy ${ncn_progname}; ac_word=$2
10268 echo "$as_me:$LINENO: checking for $ac_word" >&5
10269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10270 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10271   echo $ECHO_N "(cached) $ECHO_C" >&6
10272 else
10273   if test -n "$LIPO_FOR_TARGET"; then
10274   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10275 else
10276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10277 for as_dir in $PATH
10278 do
10279   IFS=$as_save_IFS
10280   test -z "$as_dir" && as_dir=.
10281   for ac_exec_ext in '' $ac_executable_extensions; do
10282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10283     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10285     break 2
10286   fi
10287 done
10288 done
10289
10290 fi
10291 fi
10292 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10293 if test -n "$LIPO_FOR_TARGET"; then
10294   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10295 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10296 else
10297   echo "$as_me:$LINENO: result: no" >&5
10298 echo "${ECHO_T}no" >&6
10299 fi
10300
10301     fi
10302     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10303   done
10304 fi
10305
10306 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10307   set dummy lipo
10308   if test $build = $target ; then
10309     LIPO_FOR_TARGET="$2"
10310   else
10311     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10312   fi
10313 else
10314   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10315 fi
10316
10317 else
10318   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10319 fi
10320
10321
10322
10323
10324 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10325   if test -n "$with_build_time_tools"; then
10326     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10327 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10328     if test -x $with_build_time_tools/nm; then
10329       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10330       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10331       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10332 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10333     else
10334       echo "$as_me:$LINENO: result: no" >&5
10335 echo "${ECHO_T}no" >&6
10336     fi
10337   elif test $build != $host && test $have_gcc_for_target = yes; then
10338     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10339     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10340     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10341   fi
10342 fi
10343 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10344   # Extract the first word of "nm", so it can be a program name with args.
10345 set dummy nm; ac_word=$2
10346 echo "$as_me:$LINENO: checking for $ac_word" >&5
10347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10348 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10349   echo $ECHO_N "(cached) $ECHO_C" >&6
10350 else
10351   case $NM_FOR_TARGET in
10352   [\\/]* | ?:[\\/]*)
10353   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10354   ;;
10355   *)
10356   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10357 for as_dir in $gcc_cv_tool_dirs
10358 do
10359   IFS=$as_save_IFS
10360   test -z "$as_dir" && as_dir=.
10361   for ac_exec_ext in '' $ac_executable_extensions; do
10362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10363     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10365     break 2
10366   fi
10367 done
10368 done
10369
10370   ;;
10371 esac
10372 fi
10373 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10374
10375 if test -n "$NM_FOR_TARGET"; then
10376   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10377 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10378 else
10379   echo "$as_me:$LINENO: result: no" >&5
10380 echo "${ECHO_T}no" >&6
10381 fi
10382
10383 fi
10384 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10385
10386
10387 if test -n "$NM_FOR_TARGET"; then
10388   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10389 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10390   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10391 fi
10392
10393 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10394   for ncn_progname in nm; do
10395     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10396 set dummy ${ncn_progname}; ac_word=$2
10397 echo "$as_me:$LINENO: checking for $ac_word" >&5
10398 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10399 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10400   echo $ECHO_N "(cached) $ECHO_C" >&6
10401 else
10402   if test -n "$NM_FOR_TARGET"; then
10403   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10404 else
10405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10406 for as_dir in $PATH
10407 do
10408   IFS=$as_save_IFS
10409   test -z "$as_dir" && as_dir=.
10410   for ac_exec_ext in '' $ac_executable_extensions; do
10411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10412     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10414     break 2
10415   fi
10416 done
10417 done
10418
10419 fi
10420 fi
10421 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10422 if test -n "$NM_FOR_TARGET"; then
10423   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10424 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10425 else
10426   echo "$as_me:$LINENO: result: no" >&5
10427 echo "${ECHO_T}no" >&6
10428 fi
10429
10430   done
10431 fi
10432
10433 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10434   for ncn_progname in nm; do
10435     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10436 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10437     if test -x $with_build_time_tools/${ncn_progname}; then
10438       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10439       echo "$as_me:$LINENO: result: yes" >&5
10440 echo "${ECHO_T}yes" >&6
10441       break
10442     else
10443       echo "$as_me:$LINENO: result: no" >&5
10444 echo "${ECHO_T}no" >&6
10445     fi
10446   done
10447 fi
10448
10449 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10450   for ncn_progname in nm; do
10451     if test -n "$ncn_target_tool_prefix"; then
10452       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10453 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10454 echo "$as_me:$LINENO: checking for $ac_word" >&5
10455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10456 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10457   echo $ECHO_N "(cached) $ECHO_C" >&6
10458 else
10459   if test -n "$NM_FOR_TARGET"; then
10460   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10461 else
10462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10463 for as_dir in $PATH
10464 do
10465   IFS=$as_save_IFS
10466   test -z "$as_dir" && as_dir=.
10467   for ac_exec_ext in '' $ac_executable_extensions; do
10468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10469     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10471     break 2
10472   fi
10473 done
10474 done
10475
10476 fi
10477 fi
10478 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10479 if test -n "$NM_FOR_TARGET"; then
10480   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10481 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10482 else
10483   echo "$as_me:$LINENO: result: no" >&5
10484 echo "${ECHO_T}no" >&6
10485 fi
10486
10487     fi
10488     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10489       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10490 set dummy ${ncn_progname}; ac_word=$2
10491 echo "$as_me:$LINENO: checking for $ac_word" >&5
10492 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10493 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10494   echo $ECHO_N "(cached) $ECHO_C" >&6
10495 else
10496   if test -n "$NM_FOR_TARGET"; then
10497   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10498 else
10499 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10500 for as_dir in $PATH
10501 do
10502   IFS=$as_save_IFS
10503   test -z "$as_dir" && as_dir=.
10504   for ac_exec_ext in '' $ac_executable_extensions; do
10505   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10506     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10507     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10508     break 2
10509   fi
10510 done
10511 done
10512
10513 fi
10514 fi
10515 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10516 if test -n "$NM_FOR_TARGET"; then
10517   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10518 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10519 else
10520   echo "$as_me:$LINENO: result: no" >&5
10521 echo "${ECHO_T}no" >&6
10522 fi
10523
10524     fi
10525     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10526   done
10527 fi
10528
10529 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10530   set dummy nm
10531   if test $build = $target ; then
10532     NM_FOR_TARGET="$2"
10533   else
10534     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10535   fi
10536 else
10537   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10538 fi
10539
10540 else
10541   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10542 fi
10543
10544
10545
10546
10547 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10548   if test -n "$with_build_time_tools"; then
10549     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10550 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10551     if test -x $with_build_time_tools/objdump; then
10552       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10553       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10554       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10555 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10556     else
10557       echo "$as_me:$LINENO: result: no" >&5
10558 echo "${ECHO_T}no" >&6
10559     fi
10560   elif test $build != $host && test $have_gcc_for_target = yes; then
10561     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10562     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10563     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10564   fi
10565 fi
10566 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10567   # Extract the first word of "objdump", so it can be a program name with args.
10568 set dummy objdump; ac_word=$2
10569 echo "$as_me:$LINENO: checking for $ac_word" >&5
10570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10571 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10572   echo $ECHO_N "(cached) $ECHO_C" >&6
10573 else
10574   case $OBJDUMP_FOR_TARGET in
10575   [\\/]* | ?:[\\/]*)
10576   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10577   ;;
10578   *)
10579   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10580 for as_dir in $gcc_cv_tool_dirs
10581 do
10582   IFS=$as_save_IFS
10583   test -z "$as_dir" && as_dir=.
10584   for ac_exec_ext in '' $ac_executable_extensions; do
10585   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10586     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10587     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10588     break 2
10589   fi
10590 done
10591 done
10592
10593   ;;
10594 esac
10595 fi
10596 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10597
10598 if test -n "$OBJDUMP_FOR_TARGET"; then
10599   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10600 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10601 else
10602   echo "$as_me:$LINENO: result: no" >&5
10603 echo "${ECHO_T}no" >&6
10604 fi
10605
10606 fi
10607 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10608
10609
10610 if test -n "$OBJDUMP_FOR_TARGET"; then
10611   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10612 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10613   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10614 fi
10615
10616 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10617   for ncn_progname in objdump; do
10618     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10619 set dummy ${ncn_progname}; ac_word=$2
10620 echo "$as_me:$LINENO: checking for $ac_word" >&5
10621 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10622 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10623   echo $ECHO_N "(cached) $ECHO_C" >&6
10624 else
10625   if test -n "$OBJDUMP_FOR_TARGET"; then
10626   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10627 else
10628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10629 for as_dir in $PATH
10630 do
10631   IFS=$as_save_IFS
10632   test -z "$as_dir" && as_dir=.
10633   for ac_exec_ext in '' $ac_executable_extensions; do
10634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10635     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10637     break 2
10638   fi
10639 done
10640 done
10641
10642 fi
10643 fi
10644 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10645 if test -n "$OBJDUMP_FOR_TARGET"; then
10646   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10647 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10648 else
10649   echo "$as_me:$LINENO: result: no" >&5
10650 echo "${ECHO_T}no" >&6
10651 fi
10652
10653   done
10654 fi
10655
10656 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10657   for ncn_progname in objdump; do
10658     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10659 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10660     if test -x $with_build_time_tools/${ncn_progname}; then
10661       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10662       echo "$as_me:$LINENO: result: yes" >&5
10663 echo "${ECHO_T}yes" >&6
10664       break
10665     else
10666       echo "$as_me:$LINENO: result: no" >&5
10667 echo "${ECHO_T}no" >&6
10668     fi
10669   done
10670 fi
10671
10672 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10673   for ncn_progname in objdump; do
10674     if test -n "$ncn_target_tool_prefix"; then
10675       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10676 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10677 echo "$as_me:$LINENO: checking for $ac_word" >&5
10678 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10679 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10680   echo $ECHO_N "(cached) $ECHO_C" >&6
10681 else
10682   if test -n "$OBJDUMP_FOR_TARGET"; then
10683   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10684 else
10685 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10686 for as_dir in $PATH
10687 do
10688   IFS=$as_save_IFS
10689   test -z "$as_dir" && as_dir=.
10690   for ac_exec_ext in '' $ac_executable_extensions; do
10691   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10692     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10693     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10694     break 2
10695   fi
10696 done
10697 done
10698
10699 fi
10700 fi
10701 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10702 if test -n "$OBJDUMP_FOR_TARGET"; then
10703   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10704 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10705 else
10706   echo "$as_me:$LINENO: result: no" >&5
10707 echo "${ECHO_T}no" >&6
10708 fi
10709
10710     fi
10711     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10712       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10713 set dummy ${ncn_progname}; ac_word=$2
10714 echo "$as_me:$LINENO: checking for $ac_word" >&5
10715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10716 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10717   echo $ECHO_N "(cached) $ECHO_C" >&6
10718 else
10719   if test -n "$OBJDUMP_FOR_TARGET"; then
10720   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10721 else
10722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10723 for as_dir in $PATH
10724 do
10725   IFS=$as_save_IFS
10726   test -z "$as_dir" && as_dir=.
10727   for ac_exec_ext in '' $ac_executable_extensions; do
10728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10729     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10731     break 2
10732   fi
10733 done
10734 done
10735
10736 fi
10737 fi
10738 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10739 if test -n "$OBJDUMP_FOR_TARGET"; then
10740   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10741 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10742 else
10743   echo "$as_me:$LINENO: result: no" >&5
10744 echo "${ECHO_T}no" >&6
10745 fi
10746
10747     fi
10748     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10749   done
10750 fi
10751
10752 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10753   set dummy objdump
10754   if test $build = $target ; then
10755     OBJDUMP_FOR_TARGET="$2"
10756   else
10757     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10758   fi
10759 else
10760   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10761 fi
10762
10763 else
10764   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10765 fi
10766
10767
10768
10769
10770 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10771   if test -n "$with_build_time_tools"; then
10772     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10773 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10774     if test -x $with_build_time_tools/ranlib; then
10775       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10776       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10777       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10778 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10779     else
10780       echo "$as_me:$LINENO: result: no" >&5
10781 echo "${ECHO_T}no" >&6
10782     fi
10783   elif test $build != $host && test $have_gcc_for_target = yes; then
10784     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10785     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10786     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10787   fi
10788 fi
10789 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10790   # Extract the first word of "ranlib", so it can be a program name with args.
10791 set dummy ranlib; ac_word=$2
10792 echo "$as_me:$LINENO: checking for $ac_word" >&5
10793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10794 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10795   echo $ECHO_N "(cached) $ECHO_C" >&6
10796 else
10797   case $RANLIB_FOR_TARGET in
10798   [\\/]* | ?:[\\/]*)
10799   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10800   ;;
10801   *)
10802   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10803 for as_dir in $gcc_cv_tool_dirs
10804 do
10805   IFS=$as_save_IFS
10806   test -z "$as_dir" && as_dir=.
10807   for ac_exec_ext in '' $ac_executable_extensions; do
10808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10809     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10811     break 2
10812   fi
10813 done
10814 done
10815
10816   ;;
10817 esac
10818 fi
10819 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10820
10821 if test -n "$RANLIB_FOR_TARGET"; then
10822   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10823 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10824 else
10825   echo "$as_me:$LINENO: result: no" >&5
10826 echo "${ECHO_T}no" >&6
10827 fi
10828
10829 fi
10830 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10831
10832
10833 if test -n "$RANLIB_FOR_TARGET"; then
10834   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10835 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10836   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10837 fi
10838
10839 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10840   for ncn_progname in ranlib; do
10841     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10842 set dummy ${ncn_progname}; ac_word=$2
10843 echo "$as_me:$LINENO: checking for $ac_word" >&5
10844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10845 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10846   echo $ECHO_N "(cached) $ECHO_C" >&6
10847 else
10848   if test -n "$RANLIB_FOR_TARGET"; then
10849   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10850 else
10851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10852 for as_dir in $PATH
10853 do
10854   IFS=$as_save_IFS
10855   test -z "$as_dir" && as_dir=.
10856   for ac_exec_ext in '' $ac_executable_extensions; do
10857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10858     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10860     break 2
10861   fi
10862 done
10863 done
10864
10865 fi
10866 fi
10867 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10868 if test -n "$RANLIB_FOR_TARGET"; then
10869   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10870 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10871 else
10872   echo "$as_me:$LINENO: result: no" >&5
10873 echo "${ECHO_T}no" >&6
10874 fi
10875
10876   done
10877 fi
10878
10879 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10880   for ncn_progname in ranlib; do
10881     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10882 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10883     if test -x $with_build_time_tools/${ncn_progname}; then
10884       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10885       echo "$as_me:$LINENO: result: yes" >&5
10886 echo "${ECHO_T}yes" >&6
10887       break
10888     else
10889       echo "$as_me:$LINENO: result: no" >&5
10890 echo "${ECHO_T}no" >&6
10891     fi
10892   done
10893 fi
10894
10895 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10896   for ncn_progname in ranlib; do
10897     if test -n "$ncn_target_tool_prefix"; then
10898       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10899 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10900 echo "$as_me:$LINENO: checking for $ac_word" >&5
10901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10902 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10903   echo $ECHO_N "(cached) $ECHO_C" >&6
10904 else
10905   if test -n "$RANLIB_FOR_TARGET"; then
10906   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10907 else
10908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10909 for as_dir in $PATH
10910 do
10911   IFS=$as_save_IFS
10912   test -z "$as_dir" && as_dir=.
10913   for ac_exec_ext in '' $ac_executable_extensions; do
10914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10915     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10917     break 2
10918   fi
10919 done
10920 done
10921
10922 fi
10923 fi
10924 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10925 if test -n "$RANLIB_FOR_TARGET"; then
10926   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10927 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10928 else
10929   echo "$as_me:$LINENO: result: no" >&5
10930 echo "${ECHO_T}no" >&6
10931 fi
10932
10933     fi
10934     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10935       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10936 set dummy ${ncn_progname}; ac_word=$2
10937 echo "$as_me:$LINENO: checking for $ac_word" >&5
10938 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10939 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10940   echo $ECHO_N "(cached) $ECHO_C" >&6
10941 else
10942   if test -n "$RANLIB_FOR_TARGET"; then
10943   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10944 else
10945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10946 for as_dir in $PATH
10947 do
10948   IFS=$as_save_IFS
10949   test -z "$as_dir" && as_dir=.
10950   for ac_exec_ext in '' $ac_executable_extensions; do
10951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10952     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10954     break 2
10955   fi
10956 done
10957 done
10958
10959 fi
10960 fi
10961 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10962 if test -n "$RANLIB_FOR_TARGET"; then
10963   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10964 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10965 else
10966   echo "$as_me:$LINENO: result: no" >&5
10967 echo "${ECHO_T}no" >&6
10968 fi
10969
10970     fi
10971     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10972   done
10973 fi
10974
10975 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10976   set dummy ranlib
10977   if test $build = $target ; then
10978     RANLIB_FOR_TARGET="$2"
10979   else
10980     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10981   fi
10982 else
10983   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10984 fi
10985
10986 else
10987   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10988 fi
10989
10990
10991
10992
10993 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10994   if test -n "$with_build_time_tools"; then
10995     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10996 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10997     if test -x $with_build_time_tools/strip; then
10998       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10999       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11000       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
11001 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
11002     else
11003       echo "$as_me:$LINENO: result: no" >&5
11004 echo "${ECHO_T}no" >&6
11005     fi
11006   elif test $build != $host && test $have_gcc_for_target = yes; then
11007     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
11008     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
11009     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11010   fi
11011 fi
11012 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11013   # Extract the first word of "strip", so it can be a program name with args.
11014 set dummy strip; ac_word=$2
11015 echo "$as_me:$LINENO: checking for $ac_word" >&5
11016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11017 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
11018   echo $ECHO_N "(cached) $ECHO_C" >&6
11019 else
11020   case $STRIP_FOR_TARGET in
11021   [\\/]* | ?:[\\/]*)
11022   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11023   ;;
11024   *)
11025   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11026 for as_dir in $gcc_cv_tool_dirs
11027 do
11028   IFS=$as_save_IFS
11029   test -z "$as_dir" && as_dir=.
11030   for ac_exec_ext in '' $ac_executable_extensions; do
11031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11032     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11034     break 2
11035   fi
11036 done
11037 done
11038
11039   ;;
11040 esac
11041 fi
11042 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11043
11044 if test -n "$STRIP_FOR_TARGET"; then
11045   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11046 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11047 else
11048   echo "$as_me:$LINENO: result: no" >&5
11049 echo "${ECHO_T}no" >&6
11050 fi
11051
11052 fi
11053 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11054
11055
11056 if test -n "$STRIP_FOR_TARGET"; then
11057   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11058 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11059   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11060 fi
11061
11062 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11063   for ncn_progname in strip; do
11064     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11065 set dummy ${ncn_progname}; ac_word=$2
11066 echo "$as_me:$LINENO: checking for $ac_word" >&5
11067 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11068 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11069   echo $ECHO_N "(cached) $ECHO_C" >&6
11070 else
11071   if test -n "$STRIP_FOR_TARGET"; then
11072   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11073 else
11074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11075 for as_dir in $PATH
11076 do
11077   IFS=$as_save_IFS
11078   test -z "$as_dir" && as_dir=.
11079   for ac_exec_ext in '' $ac_executable_extensions; do
11080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11081     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11083     break 2
11084   fi
11085 done
11086 done
11087
11088 fi
11089 fi
11090 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11091 if test -n "$STRIP_FOR_TARGET"; then
11092   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11093 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11094 else
11095   echo "$as_me:$LINENO: result: no" >&5
11096 echo "${ECHO_T}no" >&6
11097 fi
11098
11099   done
11100 fi
11101
11102 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11103   for ncn_progname in strip; do
11104     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11105 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11106     if test -x $with_build_time_tools/${ncn_progname}; then
11107       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11108       echo "$as_me:$LINENO: result: yes" >&5
11109 echo "${ECHO_T}yes" >&6
11110       break
11111     else
11112       echo "$as_me:$LINENO: result: no" >&5
11113 echo "${ECHO_T}no" >&6
11114     fi
11115   done
11116 fi
11117
11118 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11119   for ncn_progname in strip; do
11120     if test -n "$ncn_target_tool_prefix"; then
11121       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11122 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11123 echo "$as_me:$LINENO: checking for $ac_word" >&5
11124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11125 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11126   echo $ECHO_N "(cached) $ECHO_C" >&6
11127 else
11128   if test -n "$STRIP_FOR_TARGET"; then
11129   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11130 else
11131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11132 for as_dir in $PATH
11133 do
11134   IFS=$as_save_IFS
11135   test -z "$as_dir" && as_dir=.
11136   for ac_exec_ext in '' $ac_executable_extensions; do
11137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11138     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11140     break 2
11141   fi
11142 done
11143 done
11144
11145 fi
11146 fi
11147 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11148 if test -n "$STRIP_FOR_TARGET"; then
11149   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11150 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11151 else
11152   echo "$as_me:$LINENO: result: no" >&5
11153 echo "${ECHO_T}no" >&6
11154 fi
11155
11156     fi
11157     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11158       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11159 set dummy ${ncn_progname}; ac_word=$2
11160 echo "$as_me:$LINENO: checking for $ac_word" >&5
11161 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11162 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11163   echo $ECHO_N "(cached) $ECHO_C" >&6
11164 else
11165   if test -n "$STRIP_FOR_TARGET"; then
11166   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11167 else
11168 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11169 for as_dir in $PATH
11170 do
11171   IFS=$as_save_IFS
11172   test -z "$as_dir" && as_dir=.
11173   for ac_exec_ext in '' $ac_executable_extensions; do
11174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11175     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11177     break 2
11178   fi
11179 done
11180 done
11181
11182 fi
11183 fi
11184 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11185 if test -n "$STRIP_FOR_TARGET"; then
11186   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11187 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11188 else
11189   echo "$as_me:$LINENO: result: no" >&5
11190 echo "${ECHO_T}no" >&6
11191 fi
11192
11193     fi
11194     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11195   done
11196 fi
11197
11198 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11199   set dummy strip
11200   if test $build = $target ; then
11201     STRIP_FOR_TARGET="$2"
11202   else
11203     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11204   fi
11205 else
11206   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11207 fi
11208
11209 else
11210   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11211 fi
11212
11213
11214
11215
11216 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11217   if test -n "$with_build_time_tools"; then
11218     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11219 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11220     if test -x $with_build_time_tools/windres; then
11221       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11222       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11223       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11224 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11225     else
11226       echo "$as_me:$LINENO: result: no" >&5
11227 echo "${ECHO_T}no" >&6
11228     fi
11229   elif test $build != $host && test $have_gcc_for_target = yes; then
11230     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11231     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11232     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11233   fi
11234 fi
11235 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11236   # Extract the first word of "windres", so it can be a program name with args.
11237 set dummy windres; ac_word=$2
11238 echo "$as_me:$LINENO: checking for $ac_word" >&5
11239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11240 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11241   echo $ECHO_N "(cached) $ECHO_C" >&6
11242 else
11243   case $WINDRES_FOR_TARGET in
11244   [\\/]* | ?:[\\/]*)
11245   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11246   ;;
11247   *)
11248   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11249 for as_dir in $gcc_cv_tool_dirs
11250 do
11251   IFS=$as_save_IFS
11252   test -z "$as_dir" && as_dir=.
11253   for ac_exec_ext in '' $ac_executable_extensions; do
11254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11255     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11257     break 2
11258   fi
11259 done
11260 done
11261
11262   ;;
11263 esac
11264 fi
11265 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11266
11267 if test -n "$WINDRES_FOR_TARGET"; then
11268   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11269 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11270 else
11271   echo "$as_me:$LINENO: result: no" >&5
11272 echo "${ECHO_T}no" >&6
11273 fi
11274
11275 fi
11276 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11277
11278
11279 if test -n "$WINDRES_FOR_TARGET"; then
11280   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11281 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11282   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11283 fi
11284
11285 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11286   for ncn_progname in windres; do
11287     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11288 set dummy ${ncn_progname}; ac_word=$2
11289 echo "$as_me:$LINENO: checking for $ac_word" >&5
11290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11291 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11292   echo $ECHO_N "(cached) $ECHO_C" >&6
11293 else
11294   if test -n "$WINDRES_FOR_TARGET"; then
11295   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11296 else
11297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11298 for as_dir in $PATH
11299 do
11300   IFS=$as_save_IFS
11301   test -z "$as_dir" && as_dir=.
11302   for ac_exec_ext in '' $ac_executable_extensions; do
11303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11304     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11306     break 2
11307   fi
11308 done
11309 done
11310
11311 fi
11312 fi
11313 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11314 if test -n "$WINDRES_FOR_TARGET"; then
11315   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11316 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11317 else
11318   echo "$as_me:$LINENO: result: no" >&5
11319 echo "${ECHO_T}no" >&6
11320 fi
11321
11322   done
11323 fi
11324
11325 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11326   for ncn_progname in windres; do
11327     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11328 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11329     if test -x $with_build_time_tools/${ncn_progname}; then
11330       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11331       echo "$as_me:$LINENO: result: yes" >&5
11332 echo "${ECHO_T}yes" >&6
11333       break
11334     else
11335       echo "$as_me:$LINENO: result: no" >&5
11336 echo "${ECHO_T}no" >&6
11337     fi
11338   done
11339 fi
11340
11341 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11342   for ncn_progname in windres; do
11343     if test -n "$ncn_target_tool_prefix"; then
11344       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11345 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11346 echo "$as_me:$LINENO: checking for $ac_word" >&5
11347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11348 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11349   echo $ECHO_N "(cached) $ECHO_C" >&6
11350 else
11351   if test -n "$WINDRES_FOR_TARGET"; then
11352   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11353 else
11354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11355 for as_dir in $PATH
11356 do
11357   IFS=$as_save_IFS
11358   test -z "$as_dir" && as_dir=.
11359   for ac_exec_ext in '' $ac_executable_extensions; do
11360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11361     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11363     break 2
11364   fi
11365 done
11366 done
11367
11368 fi
11369 fi
11370 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11371 if test -n "$WINDRES_FOR_TARGET"; then
11372   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11373 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11374 else
11375   echo "$as_me:$LINENO: result: no" >&5
11376 echo "${ECHO_T}no" >&6
11377 fi
11378
11379     fi
11380     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11381       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11382 set dummy ${ncn_progname}; ac_word=$2
11383 echo "$as_me:$LINENO: checking for $ac_word" >&5
11384 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11385 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11386   echo $ECHO_N "(cached) $ECHO_C" >&6
11387 else
11388   if test -n "$WINDRES_FOR_TARGET"; then
11389   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11390 else
11391 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11392 for as_dir in $PATH
11393 do
11394   IFS=$as_save_IFS
11395   test -z "$as_dir" && as_dir=.
11396   for ac_exec_ext in '' $ac_executable_extensions; do
11397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11398     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11400     break 2
11401   fi
11402 done
11403 done
11404
11405 fi
11406 fi
11407 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11408 if test -n "$WINDRES_FOR_TARGET"; then
11409   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11410 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11411 else
11412   echo "$as_me:$LINENO: result: no" >&5
11413 echo "${ECHO_T}no" >&6
11414 fi
11415
11416     fi
11417     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11418   done
11419 fi
11420
11421 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11422   set dummy windres
11423   if test $build = $target ; then
11424     WINDRES_FOR_TARGET="$2"
11425   else
11426     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11427   fi
11428 else
11429   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11430 fi
11431
11432 else
11433   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11434 fi
11435
11436
11437
11438
11439 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11440   if test -n "$with_build_time_tools"; then
11441     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11442 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11443     if test -x $with_build_time_tools/windmc; then
11444       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11445       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11446       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11447 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11448     else
11449       echo "$as_me:$LINENO: result: no" >&5
11450 echo "${ECHO_T}no" >&6
11451     fi
11452   elif test $build != $host && test $have_gcc_for_target = yes; then
11453     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11454     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11455     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11456   fi
11457 fi
11458 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11459   # Extract the first word of "windmc", so it can be a program name with args.
11460 set dummy windmc; ac_word=$2
11461 echo "$as_me:$LINENO: checking for $ac_word" >&5
11462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11463 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11464   echo $ECHO_N "(cached) $ECHO_C" >&6
11465 else
11466   case $WINDMC_FOR_TARGET in
11467   [\\/]* | ?:[\\/]*)
11468   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11469   ;;
11470   *)
11471   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11472 for as_dir in $gcc_cv_tool_dirs
11473 do
11474   IFS=$as_save_IFS
11475   test -z "$as_dir" && as_dir=.
11476   for ac_exec_ext in '' $ac_executable_extensions; do
11477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11478     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11480     break 2
11481   fi
11482 done
11483 done
11484
11485   ;;
11486 esac
11487 fi
11488 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11489
11490 if test -n "$WINDMC_FOR_TARGET"; then
11491   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11492 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11493 else
11494   echo "$as_me:$LINENO: result: no" >&5
11495 echo "${ECHO_T}no" >&6
11496 fi
11497
11498 fi
11499 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11500
11501
11502 if test -n "$WINDMC_FOR_TARGET"; then
11503   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11504 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11505   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11506 fi
11507
11508 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11509   for ncn_progname in windmc; do
11510     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11511 set dummy ${ncn_progname}; ac_word=$2
11512 echo "$as_me:$LINENO: checking for $ac_word" >&5
11513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11514 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11515   echo $ECHO_N "(cached) $ECHO_C" >&6
11516 else
11517   if test -n "$WINDMC_FOR_TARGET"; then
11518   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11519 else
11520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11521 for as_dir in $PATH
11522 do
11523   IFS=$as_save_IFS
11524   test -z "$as_dir" && as_dir=.
11525   for ac_exec_ext in '' $ac_executable_extensions; do
11526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11527     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11529     break 2
11530   fi
11531 done
11532 done
11533
11534 fi
11535 fi
11536 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11537 if test -n "$WINDMC_FOR_TARGET"; then
11538   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11539 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11540 else
11541   echo "$as_me:$LINENO: result: no" >&5
11542 echo "${ECHO_T}no" >&6
11543 fi
11544
11545   done
11546 fi
11547
11548 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11549   for ncn_progname in windmc; do
11550     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11551 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11552     if test -x $with_build_time_tools/${ncn_progname}; then
11553       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11554       echo "$as_me:$LINENO: result: yes" >&5
11555 echo "${ECHO_T}yes" >&6
11556       break
11557     else
11558       echo "$as_me:$LINENO: result: no" >&5
11559 echo "${ECHO_T}no" >&6
11560     fi
11561   done
11562 fi
11563
11564 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11565   for ncn_progname in windmc; do
11566     if test -n "$ncn_target_tool_prefix"; then
11567       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11568 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11569 echo "$as_me:$LINENO: checking for $ac_word" >&5
11570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11571 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11572   echo $ECHO_N "(cached) $ECHO_C" >&6
11573 else
11574   if test -n "$WINDMC_FOR_TARGET"; then
11575   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11576 else
11577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11578 for as_dir in $PATH
11579 do
11580   IFS=$as_save_IFS
11581   test -z "$as_dir" && as_dir=.
11582   for ac_exec_ext in '' $ac_executable_extensions; do
11583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11584     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11586     break 2
11587   fi
11588 done
11589 done
11590
11591 fi
11592 fi
11593 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11594 if test -n "$WINDMC_FOR_TARGET"; then
11595   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11596 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11597 else
11598   echo "$as_me:$LINENO: result: no" >&5
11599 echo "${ECHO_T}no" >&6
11600 fi
11601
11602     fi
11603     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11604       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11605 set dummy ${ncn_progname}; ac_word=$2
11606 echo "$as_me:$LINENO: checking for $ac_word" >&5
11607 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11608 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11609   echo $ECHO_N "(cached) $ECHO_C" >&6
11610 else
11611   if test -n "$WINDMC_FOR_TARGET"; then
11612   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11613 else
11614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11615 for as_dir in $PATH
11616 do
11617   IFS=$as_save_IFS
11618   test -z "$as_dir" && as_dir=.
11619   for ac_exec_ext in '' $ac_executable_extensions; do
11620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11621     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11623     break 2
11624   fi
11625 done
11626 done
11627
11628 fi
11629 fi
11630 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11631 if test -n "$WINDMC_FOR_TARGET"; then
11632   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11633 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11634 else
11635   echo "$as_me:$LINENO: result: no" >&5
11636 echo "${ECHO_T}no" >&6
11637 fi
11638
11639     fi
11640     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11641   done
11642 fi
11643
11644 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11645   set dummy windmc
11646   if test $build = $target ; then
11647     WINDMC_FOR_TARGET="$2"
11648   else
11649     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11650   fi
11651 else
11652   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11653 fi
11654
11655 else
11656   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11657 fi
11658
11659
11660 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11661
11662 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11663 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11664 if test "x${build}" != "x${host}" ; then
11665   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11666     # We already found the complete path
11667     ac_dir=`dirname $AR_FOR_TARGET`
11668     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11669 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11670   else
11671     # Canadian cross, just use what we found
11672     echo "$as_me:$LINENO: result: pre-installed" >&5
11673 echo "${ECHO_T}pre-installed" >&6
11674   fi
11675 else
11676   ok=yes
11677   case " ${configdirs} " in
11678     *" binutils "*) ;;
11679     *) ok=no ;;
11680   esac
11681
11682   if test $ok = yes; then
11683     # An in-tree tool is available and we can use it
11684     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11685     echo "$as_me:$LINENO: result: just compiled" >&5
11686 echo "${ECHO_T}just compiled" >&6
11687   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11688     # We already found the complete path
11689     ac_dir=`dirname $AR_FOR_TARGET`
11690     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11691 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11692   elif test "x$target" = "x$host"; then
11693     # We can use an host tool
11694     AR_FOR_TARGET='$(AR)'
11695     echo "$as_me:$LINENO: result: host tool" >&5
11696 echo "${ECHO_T}host tool" >&6
11697   else
11698     # We need a cross tool
11699     echo "$as_me:$LINENO: result: pre-installed" >&5
11700 echo "${ECHO_T}pre-installed" >&6
11701   fi
11702 fi
11703
11704 echo "$as_me:$LINENO: checking where to find the target as" >&5
11705 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11706 if test "x${build}" != "x${host}" ; then
11707   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11708     # We already found the complete path
11709     ac_dir=`dirname $AS_FOR_TARGET`
11710     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11711 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11712   else
11713     # Canadian cross, just use what we found
11714     echo "$as_me:$LINENO: result: pre-installed" >&5
11715 echo "${ECHO_T}pre-installed" >&6
11716   fi
11717 else
11718   ok=yes
11719   case " ${configdirs} " in
11720     *" gas "*) ;;
11721     *) ok=no ;;
11722   esac
11723
11724   if test $ok = yes; then
11725     # An in-tree tool is available and we can use it
11726     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11727     echo "$as_me:$LINENO: result: just compiled" >&5
11728 echo "${ECHO_T}just compiled" >&6
11729   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11730     # We already found the complete path
11731     ac_dir=`dirname $AS_FOR_TARGET`
11732     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11733 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11734   elif test "x$target" = "x$host"; then
11735     # We can use an host tool
11736     AS_FOR_TARGET='$(AS)'
11737     echo "$as_me:$LINENO: result: host tool" >&5
11738 echo "${ECHO_T}host tool" >&6
11739   else
11740     # We need a cross tool
11741     echo "$as_me:$LINENO: result: pre-installed" >&5
11742 echo "${ECHO_T}pre-installed" >&6
11743   fi
11744 fi
11745
11746 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11747 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11748 if test "x${build}" != "x${host}" ; then
11749   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11750     # We already found the complete path
11751     ac_dir=`dirname $CC_FOR_TARGET`
11752     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11753 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11754   else
11755     # Canadian cross, just use what we found
11756     echo "$as_me:$LINENO: result: pre-installed" >&5
11757 echo "${ECHO_T}pre-installed" >&6
11758   fi
11759 else
11760   ok=yes
11761   case " ${configdirs} " in
11762     *" gcc "*) ;;
11763     *) ok=no ;;
11764   esac
11765
11766   if test $ok = yes; then
11767     # An in-tree tool is available and we can use it
11768     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11769     echo "$as_me:$LINENO: result: just compiled" >&5
11770 echo "${ECHO_T}just compiled" >&6
11771   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11772     # We already found the complete path
11773     ac_dir=`dirname $CC_FOR_TARGET`
11774     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11775 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11776   elif test "x$target" = "x$host"; then
11777     # We can use an host tool
11778     CC_FOR_TARGET='$(CC)'
11779     echo "$as_me:$LINENO: result: host tool" >&5
11780 echo "${ECHO_T}host tool" >&6
11781   else
11782     # We need a cross tool
11783     echo "$as_me:$LINENO: result: pre-installed" >&5
11784 echo "${ECHO_T}pre-installed" >&6
11785   fi
11786 fi
11787
11788 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11789 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11790 if test "x${build}" != "x${host}" ; then
11791   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11792     # We already found the complete path
11793     ac_dir=`dirname $CXX_FOR_TARGET`
11794     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11795 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11796   else
11797     # Canadian cross, just use what we found
11798     echo "$as_me:$LINENO: result: pre-installed" >&5
11799 echo "${ECHO_T}pre-installed" >&6
11800   fi
11801 else
11802   ok=yes
11803   case " ${configdirs} " in
11804     *" gcc "*) ;;
11805     *) ok=no ;;
11806   esac
11807   case ,${enable_languages}, in
11808     *,c++,*) ;;
11809     *) ok=no ;;
11810   esac
11811   if test $ok = yes; then
11812     # An in-tree tool is available and we can use it
11813     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'
11814     echo "$as_me:$LINENO: result: just compiled" >&5
11815 echo "${ECHO_T}just compiled" >&6
11816   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11817     # We already found the complete path
11818     ac_dir=`dirname $CXX_FOR_TARGET`
11819     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11820 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11821   elif test "x$target" = "x$host"; then
11822     # We can use an host tool
11823     CXX_FOR_TARGET='$(CXX)'
11824     echo "$as_me:$LINENO: result: host tool" >&5
11825 echo "${ECHO_T}host tool" >&6
11826   else
11827     # We need a cross tool
11828     echo "$as_me:$LINENO: result: pre-installed" >&5
11829 echo "${ECHO_T}pre-installed" >&6
11830   fi
11831 fi
11832
11833 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11834 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11835 if test "x${build}" != "x${host}" ; then
11836   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11837     # We already found the complete path
11838     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11839     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11840 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11841   else
11842     # Canadian cross, just use what we found
11843     echo "$as_me:$LINENO: result: pre-installed" >&5
11844 echo "${ECHO_T}pre-installed" >&6
11845   fi
11846 else
11847   ok=yes
11848   case " ${configdirs} " in
11849     *" gcc "*) ;;
11850     *) ok=no ;;
11851   esac
11852   case ,${enable_languages}, in
11853     *,c++,*) ;;
11854     *) ok=no ;;
11855   esac
11856   if test $ok = yes; then
11857     # An in-tree tool is available and we can use it
11858     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'
11859     echo "$as_me:$LINENO: result: just compiled" >&5
11860 echo "${ECHO_T}just compiled" >&6
11861   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11862     # We already found the complete path
11863     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11864     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11865 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11866   elif test "x$target" = "x$host"; then
11867     # We can use an host tool
11868     RAW_CXX_FOR_TARGET='$(CXX)'
11869     echo "$as_me:$LINENO: result: host tool" >&5
11870 echo "${ECHO_T}host tool" >&6
11871   else
11872     # We need a cross tool
11873     echo "$as_me:$LINENO: result: pre-installed" >&5
11874 echo "${ECHO_T}pre-installed" >&6
11875   fi
11876 fi
11877
11878 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11879 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11880 if test "x${build}" != "x${host}" ; then
11881   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11882     # We already found the complete path
11883     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11884     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11885 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11886   else
11887     # Canadian cross, just use what we found
11888     echo "$as_me:$LINENO: result: pre-installed" >&5
11889 echo "${ECHO_T}pre-installed" >&6
11890   fi
11891 else
11892   ok=yes
11893   case " ${configdirs} " in
11894     *" binutils "*) ;;
11895     *) ok=no ;;
11896   esac
11897
11898   if test $ok = yes; then
11899     # An in-tree tool is available and we can use it
11900     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11901     echo "$as_me:$LINENO: result: just compiled" >&5
11902 echo "${ECHO_T}just compiled" >&6
11903   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11904     # We already found the complete path
11905     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11906     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11907 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11908   elif test "x$target" = "x$host"; then
11909     # We can use an host tool
11910     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11911     echo "$as_me:$LINENO: result: host tool" >&5
11912 echo "${ECHO_T}host tool" >&6
11913   else
11914     # We need a cross tool
11915     echo "$as_me:$LINENO: result: pre-installed" >&5
11916 echo "${ECHO_T}pre-installed" >&6
11917   fi
11918 fi
11919
11920 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11921 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11922 if test "x${build}" != "x${host}" ; then
11923   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11924     # We already found the complete path
11925     ac_dir=`dirname $GCC_FOR_TARGET`
11926     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11927 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11928   else
11929     # Canadian cross, just use what we found
11930     echo "$as_me:$LINENO: result: pre-installed" >&5
11931 echo "${ECHO_T}pre-installed" >&6
11932   fi
11933 else
11934   ok=yes
11935   case " ${configdirs} " in
11936     *" gcc "*) ;;
11937     *) ok=no ;;
11938   esac
11939
11940   if test $ok = yes; then
11941     # An in-tree tool is available and we can use it
11942     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11943     echo "$as_me:$LINENO: result: just compiled" >&5
11944 echo "${ECHO_T}just compiled" >&6
11945   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11946     # We already found the complete path
11947     ac_dir=`dirname $GCC_FOR_TARGET`
11948     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11949 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11950   elif test "x$target" = "x$host"; then
11951     # We can use an host tool
11952     GCC_FOR_TARGET='$()'
11953     echo "$as_me:$LINENO: result: host tool" >&5
11954 echo "${ECHO_T}host tool" >&6
11955   else
11956     # We need a cross tool
11957     echo "$as_me:$LINENO: result: pre-installed" >&5
11958 echo "${ECHO_T}pre-installed" >&6
11959   fi
11960 fi
11961
11962 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11963 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11964 if test "x${build}" != "x${host}" ; then
11965   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11966     # We already found the complete path
11967     ac_dir=`dirname $GCJ_FOR_TARGET`
11968     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11969 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11970   else
11971     # Canadian cross, just use what we found
11972     echo "$as_me:$LINENO: result: pre-installed" >&5
11973 echo "${ECHO_T}pre-installed" >&6
11974   fi
11975 else
11976   ok=yes
11977   case " ${configdirs} " in
11978     *" gcc "*) ;;
11979     *) ok=no ;;
11980   esac
11981   case ,${enable_languages}, in
11982     *,java,*) ;;
11983     *) ok=no ;;
11984   esac
11985   if test $ok = yes; then
11986     # An in-tree tool is available and we can use it
11987     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11988     echo "$as_me:$LINENO: result: just compiled" >&5
11989 echo "${ECHO_T}just compiled" >&6
11990   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11991     # We already found the complete path
11992     ac_dir=`dirname $GCJ_FOR_TARGET`
11993     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11994 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11995   elif test "x$target" = "x$host"; then
11996     # We can use an host tool
11997     GCJ_FOR_TARGET='$(GCJ)'
11998     echo "$as_me:$LINENO: result: host tool" >&5
11999 echo "${ECHO_T}host tool" >&6
12000   else
12001     # We need a cross tool
12002     echo "$as_me:$LINENO: result: pre-installed" >&5
12003 echo "${ECHO_T}pre-installed" >&6
12004   fi
12005 fi
12006
12007 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
12008 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
12009 if test "x${build}" != "x${host}" ; then
12010   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12011     # We already found the complete path
12012     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12013     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12014 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12015   else
12016     # Canadian cross, just use what we found
12017     echo "$as_me:$LINENO: result: pre-installed" >&5
12018 echo "${ECHO_T}pre-installed" >&6
12019   fi
12020 else
12021   ok=yes
12022   case " ${configdirs} " in
12023     *" gcc "*) ;;
12024     *) ok=no ;;
12025   esac
12026   case ,${enable_languages}, in
12027     *,fortran,*) ;;
12028     *) ok=no ;;
12029   esac
12030   if test $ok = yes; then
12031     # An in-tree tool is available and we can use it
12032     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12033     echo "$as_me:$LINENO: result: just compiled" >&5
12034 echo "${ECHO_T}just compiled" >&6
12035   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12036     # We already found the complete path
12037     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12038     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12039 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12040   elif test "x$target" = "x$host"; then
12041     # We can use an host tool
12042     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12043     echo "$as_me:$LINENO: result: host tool" >&5
12044 echo "${ECHO_T}host tool" >&6
12045   else
12046     # We need a cross tool
12047     echo "$as_me:$LINENO: result: pre-installed" >&5
12048 echo "${ECHO_T}pre-installed" >&6
12049   fi
12050 fi
12051
12052 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12053 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12054 if test "x${build}" != "x${host}" ; then
12055   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12056     # We already found the complete path
12057     ac_dir=`dirname $LD_FOR_TARGET`
12058     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12059 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12060   else
12061     # Canadian cross, just use what we found
12062     echo "$as_me:$LINENO: result: pre-installed" >&5
12063 echo "${ECHO_T}pre-installed" >&6
12064   fi
12065 else
12066   ok=yes
12067   case " ${configdirs} " in
12068     *" ld "*) ;;
12069     *) ok=no ;;
12070   esac
12071
12072   if test $ok = yes; then
12073     # An in-tree tool is available and we can use it
12074     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12075     echo "$as_me:$LINENO: result: just compiled" >&5
12076 echo "${ECHO_T}just compiled" >&6
12077   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12078     # We already found the complete path
12079     ac_dir=`dirname $LD_FOR_TARGET`
12080     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12081 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12082   elif test "x$target" = "x$host"; then
12083     # We can use an host tool
12084     LD_FOR_TARGET='$(LD)'
12085     echo "$as_me:$LINENO: result: host tool" >&5
12086 echo "${ECHO_T}host tool" >&6
12087   else
12088     # We need a cross tool
12089     echo "$as_me:$LINENO: result: pre-installed" >&5
12090 echo "${ECHO_T}pre-installed" >&6
12091   fi
12092 fi
12093
12094 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12095 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12096 if test "x${build}" != "x${host}" ; then
12097   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12098     # We already found the complete path
12099     ac_dir=`dirname $LIPO_FOR_TARGET`
12100     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12101 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12102   else
12103     # Canadian cross, just use what we found
12104     echo "$as_me:$LINENO: result: pre-installed" >&5
12105 echo "${ECHO_T}pre-installed" >&6
12106   fi
12107 else
12108   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12109     # We already found the complete path
12110     ac_dir=`dirname $LIPO_FOR_TARGET`
12111     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12112 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12113   elif test "x$target" = "x$host"; then
12114     # We can use an host tool
12115     LIPO_FOR_TARGET='$(LIPO)'
12116     echo "$as_me:$LINENO: result: host tool" >&5
12117 echo "${ECHO_T}host tool" >&6
12118   else
12119     # We need a cross tool
12120     echo "$as_me:$LINENO: result: pre-installed" >&5
12121 echo "${ECHO_T}pre-installed" >&6
12122   fi
12123 fi
12124
12125 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12126 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12127 if test "x${build}" != "x${host}" ; then
12128   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12129     # We already found the complete path
12130     ac_dir=`dirname $NM_FOR_TARGET`
12131     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12132 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12133   else
12134     # Canadian cross, just use what we found
12135     echo "$as_me:$LINENO: result: pre-installed" >&5
12136 echo "${ECHO_T}pre-installed" >&6
12137   fi
12138 else
12139   ok=yes
12140   case " ${configdirs} " in
12141     *" binutils "*) ;;
12142     *) ok=no ;;
12143   esac
12144
12145   if test $ok = yes; then
12146     # An in-tree tool is available and we can use it
12147     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12148     echo "$as_me:$LINENO: result: just compiled" >&5
12149 echo "${ECHO_T}just compiled" >&6
12150   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12151     # We already found the complete path
12152     ac_dir=`dirname $NM_FOR_TARGET`
12153     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12154 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12155   elif test "x$target" = "x$host"; then
12156     # We can use an host tool
12157     NM_FOR_TARGET='$(NM)'
12158     echo "$as_me:$LINENO: result: host tool" >&5
12159 echo "${ECHO_T}host tool" >&6
12160   else
12161     # We need a cross tool
12162     echo "$as_me:$LINENO: result: pre-installed" >&5
12163 echo "${ECHO_T}pre-installed" >&6
12164   fi
12165 fi
12166
12167 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12168 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12169 if test "x${build}" != "x${host}" ; then
12170   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12171     # We already found the complete path
12172     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12173     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12174 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12175   else
12176     # Canadian cross, just use what we found
12177     echo "$as_me:$LINENO: result: pre-installed" >&5
12178 echo "${ECHO_T}pre-installed" >&6
12179   fi
12180 else
12181   ok=yes
12182   case " ${configdirs} " in
12183     *" binutils "*) ;;
12184     *) ok=no ;;
12185   esac
12186
12187   if test $ok = yes; then
12188     # An in-tree tool is available and we can use it
12189     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12190     echo "$as_me:$LINENO: result: just compiled" >&5
12191 echo "${ECHO_T}just compiled" >&6
12192   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12193     # We already found the complete path
12194     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12195     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12196 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12197   elif test "x$target" = "x$host"; then
12198     # We can use an host tool
12199     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12200     echo "$as_me:$LINENO: result: host tool" >&5
12201 echo "${ECHO_T}host tool" >&6
12202   else
12203     # We need a cross tool
12204     echo "$as_me:$LINENO: result: pre-installed" >&5
12205 echo "${ECHO_T}pre-installed" >&6
12206   fi
12207 fi
12208
12209 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12210 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12211 if test "x${build}" != "x${host}" ; then
12212   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12213     # We already found the complete path
12214     ac_dir=`dirname $RANLIB_FOR_TARGET`
12215     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12216 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12217   else
12218     # Canadian cross, just use what we found
12219     echo "$as_me:$LINENO: result: pre-installed" >&5
12220 echo "${ECHO_T}pre-installed" >&6
12221   fi
12222 else
12223   ok=yes
12224   case " ${configdirs} " in
12225     *" binutils "*) ;;
12226     *) ok=no ;;
12227   esac
12228
12229   if test $ok = yes; then
12230     # An in-tree tool is available and we can use it
12231     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12232     echo "$as_me:$LINENO: result: just compiled" >&5
12233 echo "${ECHO_T}just compiled" >&6
12234   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12235     # We already found the complete path
12236     ac_dir=`dirname $RANLIB_FOR_TARGET`
12237     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12238 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12239   elif test "x$target" = "x$host"; then
12240     # We can use an host tool
12241     RANLIB_FOR_TARGET='$(RANLIB)'
12242     echo "$as_me:$LINENO: result: host tool" >&5
12243 echo "${ECHO_T}host tool" >&6
12244   else
12245     # We need a cross tool
12246     echo "$as_me:$LINENO: result: pre-installed" >&5
12247 echo "${ECHO_T}pre-installed" >&6
12248   fi
12249 fi
12250
12251 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12252 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12253 if test "x${build}" != "x${host}" ; then
12254   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12255     # We already found the complete path
12256     ac_dir=`dirname $STRIP_FOR_TARGET`
12257     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12258 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12259   else
12260     # Canadian cross, just use what we found
12261     echo "$as_me:$LINENO: result: pre-installed" >&5
12262 echo "${ECHO_T}pre-installed" >&6
12263   fi
12264 else
12265   ok=yes
12266   case " ${configdirs} " in
12267     *" binutils "*) ;;
12268     *) ok=no ;;
12269   esac
12270
12271   if test $ok = yes; then
12272     # An in-tree tool is available and we can use it
12273     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12274     echo "$as_me:$LINENO: result: just compiled" >&5
12275 echo "${ECHO_T}just compiled" >&6
12276   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12277     # We already found the complete path
12278     ac_dir=`dirname $STRIP_FOR_TARGET`
12279     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12280 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12281   elif test "x$target" = "x$host"; then
12282     # We can use an host tool
12283     STRIP_FOR_TARGET='$(STRIP)'
12284     echo "$as_me:$LINENO: result: host tool" >&5
12285 echo "${ECHO_T}host tool" >&6
12286   else
12287     # We need a cross tool
12288     echo "$as_me:$LINENO: result: pre-installed" >&5
12289 echo "${ECHO_T}pre-installed" >&6
12290   fi
12291 fi
12292
12293 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12294 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12295 if test "x${build}" != "x${host}" ; then
12296   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12297     # We already found the complete path
12298     ac_dir=`dirname $WINDRES_FOR_TARGET`
12299     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12300 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12301   else
12302     # Canadian cross, just use what we found
12303     echo "$as_me:$LINENO: result: pre-installed" >&5
12304 echo "${ECHO_T}pre-installed" >&6
12305   fi
12306 else
12307   ok=yes
12308   case " ${configdirs} " in
12309     *" binutils "*) ;;
12310     *) ok=no ;;
12311   esac
12312
12313   if test $ok = yes; then
12314     # An in-tree tool is available and we can use it
12315     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12316     echo "$as_me:$LINENO: result: just compiled" >&5
12317 echo "${ECHO_T}just compiled" >&6
12318   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12319     # We already found the complete path
12320     ac_dir=`dirname $WINDRES_FOR_TARGET`
12321     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12322 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12323   elif test "x$target" = "x$host"; then
12324     # We can use an host tool
12325     WINDRES_FOR_TARGET='$(WINDRES)'
12326     echo "$as_me:$LINENO: result: host tool" >&5
12327 echo "${ECHO_T}host tool" >&6
12328   else
12329     # We need a cross tool
12330     echo "$as_me:$LINENO: result: pre-installed" >&5
12331 echo "${ECHO_T}pre-installed" >&6
12332   fi
12333 fi
12334
12335 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12336 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12337 if test "x${build}" != "x${host}" ; then
12338   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12339     # We already found the complete path
12340     ac_dir=`dirname $WINDMC_FOR_TARGET`
12341     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12342 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12343   else
12344     # Canadian cross, just use what we found
12345     echo "$as_me:$LINENO: result: pre-installed" >&5
12346 echo "${ECHO_T}pre-installed" >&6
12347   fi
12348 else
12349   ok=yes
12350   case " ${configdirs} " in
12351     *" binutils "*) ;;
12352     *) ok=no ;;
12353   esac
12354
12355   if test $ok = yes; then
12356     # An in-tree tool is available and we can use it
12357     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12358     echo "$as_me:$LINENO: result: just compiled" >&5
12359 echo "${ECHO_T}just compiled" >&6
12360   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12361     # We already found the complete path
12362     ac_dir=`dirname $WINDMC_FOR_TARGET`
12363     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12364 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12365   elif test "x$target" = "x$host"; then
12366     # We can use an host tool
12367     WINDMC_FOR_TARGET='$(WINDMC)'
12368     echo "$as_me:$LINENO: result: host tool" >&5
12369 echo "${ECHO_T}host tool" >&6
12370   else
12371     # We need a cross tool
12372     echo "$as_me:$LINENO: result: pre-installed" >&5
12373 echo "${ECHO_T}pre-installed" >&6
12374   fi
12375 fi
12376
12377
12378
12379
12380
12381 # Certain tools may need extra flags.
12382 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12383 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12384 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12385
12386 # When building target libraries, except in a Canadian cross, we use
12387 # the same toolchain as the compiler we just built.
12388 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12389 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12390 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12391 if test $host = $build; then
12392   case " $configdirs " in
12393     *" gcc "*)
12394       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12395       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12396       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12397       ;;
12398   esac
12399 fi
12400
12401
12402
12403
12404
12405 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12406 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12407 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12408 if test "${enable_maintainer_mode+set}" = set; then
12409   enableval="$enable_maintainer_mode"
12410   USE_MAINTAINER_MODE=$enableval
12411 else
12412   USE_MAINTAINER_MODE=no
12413 fi;
12414 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12415 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12416
12417
12418 if test "$USE_MAINTAINER_MODE" = yes; then
12419   MAINTAINER_MODE_TRUE=
12420   MAINTAINER_MODE_FALSE='#'
12421 else
12422   MAINTAINER_MODE_TRUE='#'
12423   MAINTAINER_MODE_FALSE=
12424 fi
12425 MAINT=$MAINTAINER_MODE_TRUE
12426
12427 # ---------------------
12428 # GCC bootstrap support
12429 # ---------------------
12430
12431 # Stage specific cflags for build.
12432 stage1_cflags="-g"
12433 case $build in
12434   vax-*-*)
12435     case ${GCC} in
12436       yes) stage1_cflags="-g -Wa,-J" ;;
12437       *) stage1_cflags="-g -J" ;;
12438     esac ;;
12439 esac
12440
12441 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12442 if test "$GCC" = yes; then
12443   saved_CFLAGS="$CFLAGS"
12444
12445   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12446   CFLAGS="$CFLAGS -fkeep-inline-functions"
12447   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12448 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12449   cat >conftest.$ac_ext <<_ACEOF
12450 /* confdefs.h.  */
12451 _ACEOF
12452 cat confdefs.h >>conftest.$ac_ext
12453 cat >>conftest.$ac_ext <<_ACEOF
12454 /* end confdefs.h.  */
12455
12456 #if (__GNUC__ < 3) \
12457     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12458                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12459 #error http://gcc.gnu.org/PR29382
12460 #endif
12461
12462 int
12463 main ()
12464 {
12465
12466   ;
12467   return 0;
12468 }
12469 _ACEOF
12470 rm -f conftest.$ac_objext
12471 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12472   (eval $ac_compile) 2>conftest.er1
12473   ac_status=$?
12474   grep -v '^ *+' conftest.er1 >conftest.err
12475   rm -f conftest.er1
12476   cat conftest.err >&5
12477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12478   (exit $ac_status); } &&
12479          { ac_try='test -z "$ac_c_werror_flag"
12480                          || test ! -s conftest.err'
12481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12482   (eval $ac_try) 2>&5
12483   ac_status=$?
12484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12485   (exit $ac_status); }; } &&
12486          { ac_try='test -s conftest.$ac_objext'
12487   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12488   (eval $ac_try) 2>&5
12489   ac_status=$?
12490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12491   (exit $ac_status); }; }; then
12492   echo "$as_me:$LINENO: result: yes" >&5
12493 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12494 else
12495   echo "$as_me: failed program was:" >&5
12496 sed 's/^/| /' conftest.$ac_ext >&5
12497
12498 echo "$as_me:$LINENO: result: no" >&5
12499 echo "${ECHO_T}no" >&6
12500 fi
12501 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12502
12503   CFLAGS="$saved_CFLAGS"
12504 fi
12505
12506
12507
12508 # Enable --enable-checking in stage1 of the compiler.
12509 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12510 if test "${enable_stage1_checking+set}" = set; then
12511   enableval="$enable_stage1_checking"
12512   stage1_checking=--enable-checking=${enable_stage1_checking}
12513 else
12514   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12515   stage1_checking=--enable-checking=yes,types
12516 else
12517   stage1_checking=--enable-checking=$enable_checking,types
12518 fi
12519 fi;
12520
12521
12522 # Enable -Werror in bootstrap stage2 and later.
12523 # Check whether --enable-werror or --disable-werror was given.
12524 if test "${enable_werror+set}" = set; then
12525   enableval="$enable_werror"
12526
12527 else
12528   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12529   enable_werror=yes
12530 else
12531   enable_werror=no
12532 fi
12533 fi;
12534 case ${enable_werror} in
12535   yes) stage2_werror_flag="--enable-werror-always" ;;
12536   *) stage2_werror_flag="" ;;
12537 esac
12538
12539
12540 # Flags needed to enable html installing and building
12541
12542 # Check whether --with-datarootdir or --without-datarootdir was given.
12543 if test "${with_datarootdir+set}" = set; then
12544   withval="$with_datarootdir"
12545   datarootdir="\${prefix}/${withval}"
12546 else
12547   datarootdir="\${prefix}/share"
12548 fi;
12549
12550
12551 # Check whether --with-docdir or --without-docdir was given.
12552 if test "${with_docdir+set}" = set; then
12553   withval="$with_docdir"
12554   docdir="\${prefix}/${withval}"
12555 else
12556   docdir="\${datarootdir}/doc"
12557 fi;
12558
12559
12560 # Check whether --with-pdfdir or --without-pdfdir was given.
12561 if test "${with_pdfdir+set}" = set; then
12562   withval="$with_pdfdir"
12563   pdfdir="\${prefix}/${withval}"
12564 else
12565   pdfdir="\${docdir}"
12566 fi;
12567
12568
12569 # Check whether --with-htmldir or --without-htmldir was given.
12570 if test "${with_htmldir+set}" = set; then
12571   withval="$with_htmldir"
12572   htmldir="\${prefix}/${withval}"
12573 else
12574   htmldir="\${docdir}"
12575 fi;
12576
12577
12578
12579
12580
12581
12582           ac_config_files="$ac_config_files Makefile"
12583 cat >confcache <<\_ACEOF
12584 # This file is a shell script that caches the results of configure
12585 # tests run on this system so they can be shared between configure
12586 # scripts and configure runs, see configure's option --config-cache.
12587 # It is not useful on other systems.  If it contains results you don't
12588 # want to keep, you may remove or edit it.
12589 #
12590 # config.status only pays attention to the cache file if you give it
12591 # the --recheck option to rerun configure.
12592 #
12593 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12594 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12595 # following values.
12596
12597 _ACEOF
12598
12599 # The following way of writing the cache mishandles newlines in values,
12600 # but we know of no workaround that is simple, portable, and efficient.
12601 # So, don't put newlines in cache variables' values.
12602 # Ultrix sh set writes to stderr and can't be redirected directly,
12603 # and sets the high bit in the cache file unless we assign to the vars.
12604 {
12605   (set) 2>&1 |
12606     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12607     *ac_space=\ *)
12608       # `set' does not quote correctly, so add quotes (double-quote
12609       # substitution turns \\\\ into \\, and sed turns \\ into \).
12610       sed -n \
12611         "s/'/'\\\\''/g;
12612           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12613       ;;
12614     *)
12615       # `set' quotes correctly as required by POSIX, so do not add quotes.
12616       sed -n \
12617         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12618       ;;
12619     esac;
12620 } |
12621   sed '
12622      t clear
12623      : clear
12624      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12625      t end
12626      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12627      : end' >>confcache
12628 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12629   if test -w $cache_file; then
12630     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12631     cat confcache >$cache_file
12632   else
12633     echo "not updating unwritable cache $cache_file"
12634   fi
12635 fi
12636 rm -f confcache
12637
12638 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12639 # Let make expand exec_prefix.
12640 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12641
12642 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12643 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12644 # trailing colons and then remove the whole line if VPATH becomes empty
12645 # (actually we leave an empty line to preserve line numbers).
12646 if test "x$srcdir" = x.; then
12647   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12648 s/:*\$(srcdir):*/:/;
12649 s/:*\${srcdir}:*/:/;
12650 s/:*@srcdir@:*/:/;
12651 s/^\([^=]*=[     ]*\):*/\1/;
12652 s/:*$//;
12653 s/^[^=]*=[       ]*$//;
12654 }'
12655 fi
12656
12657 # Transform confdefs.h into DEFS.
12658 # Protect against shell expansion while executing Makefile rules.
12659 # Protect against Makefile macro expansion.
12660 #
12661 # If the first sed substitution is executed (which looks for macros that
12662 # take arguments), then we branch to the quote section.  Otherwise,
12663 # look for a macro that doesn't take arguments.
12664 cat >confdef2opt.sed <<\_ACEOF
12665 t clear
12666 : clear
12667 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12668 t quote
12669 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12670 t quote
12671 d
12672 : quote
12673 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12674 s,\[,\\&,g
12675 s,\],\\&,g
12676 s,\$,$$,g
12677 p
12678 _ACEOF
12679 # We use echo to avoid assuming a particular line-breaking character.
12680 # The extra dot is to prevent the shell from consuming trailing
12681 # line-breaks from the sub-command output.  A line-break within
12682 # single-quotes doesn't work because, if this script is created in a
12683 # platform that uses two characters for line-breaks (e.g., DOS), tr
12684 # would break.
12685 ac_LF_and_DOT=`echo; echo .`
12686 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12687 rm -f confdef2opt.sed
12688
12689
12690 ac_libobjs=
12691 ac_ltlibobjs=
12692 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12693   # 1. Remove the extension, and $U if already installed.
12694   ac_i=`echo "$ac_i" |
12695          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12696   # 2. Add them.
12697   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12698   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12699 done
12700 LIBOBJS=$ac_libobjs
12701
12702 LTLIBOBJS=$ac_ltlibobjs
12703
12704
12705
12706 : ${CONFIG_STATUS=./config.status}
12707 ac_clean_files_save=$ac_clean_files
12708 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12709 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12710 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12711 cat >$CONFIG_STATUS <<_ACEOF
12712 #! $SHELL
12713 # Generated by $as_me.
12714 # Run this file to recreate the current configuration.
12715 # Compiler output produced by configure, useful for debugging
12716 # configure, is in config.log if it exists.
12717
12718 debug=false
12719 ac_cs_recheck=false
12720 ac_cs_silent=false
12721 SHELL=\${CONFIG_SHELL-$SHELL}
12722 _ACEOF
12723
12724 cat >>$CONFIG_STATUS <<\_ACEOF
12725 ## --------------------- ##
12726 ## M4sh Initialization.  ##
12727 ## --------------------- ##
12728
12729 # Be Bourne compatible
12730 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12731   emulate sh
12732   NULLCMD=:
12733   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12734   # is contrary to our usage.  Disable this feature.
12735   alias -g '${1+"$@"}'='"$@"'
12736 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12737   set -o posix
12738 fi
12739 DUALCASE=1; export DUALCASE # for MKS sh
12740
12741 # Support unset when possible.
12742 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12743   as_unset=unset
12744 else
12745   as_unset=false
12746 fi
12747
12748
12749 # Work around bugs in pre-3.0 UWIN ksh.
12750 $as_unset ENV MAIL MAILPATH
12751 PS1='$ '
12752 PS2='> '
12753 PS4='+ '
12754
12755 # NLS nuisances.
12756 for as_var in \
12757   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12758   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12759   LC_TELEPHONE LC_TIME
12760 do
12761   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12762     eval $as_var=C; export $as_var
12763   else
12764     $as_unset $as_var
12765   fi
12766 done
12767
12768 # Required to use basename.
12769 if expr a : '\(a\)' >/dev/null 2>&1; then
12770   as_expr=expr
12771 else
12772   as_expr=false
12773 fi
12774
12775 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12776   as_basename=basename
12777 else
12778   as_basename=false
12779 fi
12780
12781
12782 # Name of the executable.
12783 as_me=`$as_basename "$0" ||
12784 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12785          X"$0" : 'X\(//\)$' \| \
12786          X"$0" : 'X\(/\)$' \| \
12787          .     : '\(.\)' 2>/dev/null ||
12788 echo X/"$0" |
12789     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12790           /^X\/\(\/\/\)$/{ s//\1/; q; }
12791           /^X\/\(\/\).*/{ s//\1/; q; }
12792           s/.*/./; q'`
12793
12794
12795 # PATH needs CR, and LINENO needs CR and PATH.
12796 # Avoid depending upon Character Ranges.
12797 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12798 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12799 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12800 as_cr_digits='0123456789'
12801 as_cr_alnum=$as_cr_Letters$as_cr_digits
12802
12803 # The user is always right.
12804 if test "${PATH_SEPARATOR+set}" != set; then
12805   echo "#! /bin/sh" >conf$$.sh
12806   echo  "exit 0"   >>conf$$.sh
12807   chmod +x conf$$.sh
12808   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12809     PATH_SEPARATOR=';'
12810   else
12811     PATH_SEPARATOR=:
12812   fi
12813   rm -f conf$$.sh
12814 fi
12815
12816
12817   as_lineno_1=$LINENO
12818   as_lineno_2=$LINENO
12819   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12820   test "x$as_lineno_1" != "x$as_lineno_2" &&
12821   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12822   # Find who we are.  Look in the path if we contain no path at all
12823   # relative or not.
12824   case $0 in
12825     *[\\/]* ) as_myself=$0 ;;
12826     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12827 for as_dir in $PATH
12828 do
12829   IFS=$as_save_IFS
12830   test -z "$as_dir" && as_dir=.
12831   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12832 done
12833
12834        ;;
12835   esac
12836   # We did not find ourselves, most probably we were run as `sh COMMAND'
12837   # in which case we are not to be found in the path.
12838   if test "x$as_myself" = x; then
12839     as_myself=$0
12840   fi
12841   if test ! -f "$as_myself"; then
12842     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12843 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12844    { (exit 1); exit 1; }; }
12845   fi
12846   case $CONFIG_SHELL in
12847   '')
12848     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12849 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12850 do
12851   IFS=$as_save_IFS
12852   test -z "$as_dir" && as_dir=.
12853   for as_base in sh bash ksh sh5; do
12854          case $as_dir in
12855          /*)
12856            if ("$as_dir/$as_base" -c '
12857   as_lineno_1=$LINENO
12858   as_lineno_2=$LINENO
12859   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12860   test "x$as_lineno_1" != "x$as_lineno_2" &&
12861   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12862              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12863              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12864              CONFIG_SHELL=$as_dir/$as_base
12865              export CONFIG_SHELL
12866              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12867            fi;;
12868          esac
12869        done
12870 done
12871 ;;
12872   esac
12873
12874   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12875   # uniformly replaced by the line number.  The first 'sed' inserts a
12876   # line-number line before each line; the second 'sed' does the real
12877   # work.  The second script uses 'N' to pair each line-number line
12878   # with the numbered line, and appends trailing '-' during
12879   # substitution so that $LINENO is not a special case at line end.
12880   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12881   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12882   sed '=' <$as_myself |
12883     sed '
12884       N
12885       s,$,-,
12886       : loop
12887       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12888       t loop
12889       s,-$,,
12890       s,^['$as_cr_digits']*\n,,
12891     ' >$as_me.lineno &&
12892   chmod +x $as_me.lineno ||
12893     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12894 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12895    { (exit 1); exit 1; }; }
12896
12897   # Don't try to exec as it changes $[0], causing all sort of problems
12898   # (the dirname of $[0] is not the place where we might find the
12899   # original and so on.  Autoconf is especially sensible to this).
12900   . ./$as_me.lineno
12901   # Exit status is that of the last command.
12902   exit
12903 }
12904
12905
12906 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12907   *c*,-n*) ECHO_N= ECHO_C='
12908 ' ECHO_T='      ' ;;
12909   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12910   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12911 esac
12912
12913 if expr a : '\(a\)' >/dev/null 2>&1; then
12914   as_expr=expr
12915 else
12916   as_expr=false
12917 fi
12918
12919 rm -f conf$$ conf$$.exe conf$$.file
12920 echo >conf$$.file
12921 if ln -s conf$$.file conf$$ 2>/dev/null; then
12922   # We could just check for DJGPP; but this test a) works b) is more generic
12923   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12924   if test -f conf$$.exe; then
12925     # Don't use ln at all; we don't have any links
12926     as_ln_s='cp -p'
12927   else
12928     as_ln_s='ln -s'
12929   fi
12930 elif ln conf$$.file conf$$ 2>/dev/null; then
12931   as_ln_s=ln
12932 else
12933   as_ln_s='cp -p'
12934 fi
12935 rm -f conf$$ conf$$.exe conf$$.file
12936
12937 if mkdir -p . 2>/dev/null; then
12938   as_mkdir_p=:
12939 else
12940   test -d ./-p && rmdir ./-p
12941   as_mkdir_p=false
12942 fi
12943
12944 as_executable_p="test -f"
12945
12946 # Sed expression to map a string onto a valid CPP name.
12947 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12948
12949 # Sed expression to map a string onto a valid variable name.
12950 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12951
12952
12953 # IFS
12954 # We need space, tab and new line, in precisely that order.
12955 as_nl='
12956 '
12957 IFS="   $as_nl"
12958
12959 # CDPATH.
12960 $as_unset CDPATH
12961
12962 exec 6>&1
12963
12964 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12965 # report actual input values of CONFIG_FILES etc. instead of their
12966 # values after options handling.  Logging --version etc. is OK.
12967 exec 5>>config.log
12968 {
12969   echo
12970   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12971 ## Running $as_me. ##
12972 _ASBOX
12973 } >&5
12974 cat >&5 <<_CSEOF
12975
12976 This file was extended by $as_me, which was
12977 generated by GNU Autoconf 2.59.  Invocation command line was
12978
12979   CONFIG_FILES    = $CONFIG_FILES
12980   CONFIG_HEADERS  = $CONFIG_HEADERS
12981   CONFIG_LINKS    = $CONFIG_LINKS
12982   CONFIG_COMMANDS = $CONFIG_COMMANDS
12983   $ $0 $@
12984
12985 _CSEOF
12986 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12987 echo >&5
12988 _ACEOF
12989
12990 # Files that config.status was made for.
12991 if test -n "$ac_config_files"; then
12992   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12993 fi
12994
12995 if test -n "$ac_config_headers"; then
12996   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12997 fi
12998
12999 if test -n "$ac_config_links"; then
13000   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
13001 fi
13002
13003 if test -n "$ac_config_commands"; then
13004   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
13005 fi
13006
13007 cat >>$CONFIG_STATUS <<\_ACEOF
13008
13009 ac_cs_usage="\
13010 \`$as_me' instantiates files from templates according to the
13011 current configuration.
13012
13013 Usage: $0 [OPTIONS] [FILE]...
13014
13015   -h, --help       print this help, then exit
13016   -V, --version    print version number, then exit
13017   -q, --quiet      do not print progress messages
13018   -d, --debug      don't remove temporary files
13019       --recheck    update $as_me by reconfiguring in the same conditions
13020   --file=FILE[:TEMPLATE]
13021                    instantiate the configuration file FILE
13022
13023 Configuration files:
13024 $config_files
13025
13026 Report bugs to <bug-autoconf@gnu.org>."
13027 _ACEOF
13028
13029 cat >>$CONFIG_STATUS <<_ACEOF
13030 ac_cs_version="\\
13031 config.status
13032 configured by $0, generated by GNU Autoconf 2.59,
13033   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13034
13035 Copyright (C) 2003 Free Software Foundation, Inc.
13036 This config.status script is free software; the Free Software Foundation
13037 gives unlimited permission to copy, distribute and modify it."
13038 srcdir=$srcdir
13039 INSTALL="$INSTALL"
13040 _ACEOF
13041
13042 cat >>$CONFIG_STATUS <<\_ACEOF
13043 # If no file are specified by the user, then we need to provide default
13044 # value.  By we need to know if files were specified by the user.
13045 ac_need_defaults=:
13046 while test $# != 0
13047 do
13048   case $1 in
13049   --*=*)
13050     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13051     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13052     ac_shift=:
13053     ;;
13054   -*)
13055     ac_option=$1
13056     ac_optarg=$2
13057     ac_shift=shift
13058     ;;
13059   *) # This is not an option, so the user has probably given explicit
13060      # arguments.
13061      ac_option=$1
13062      ac_need_defaults=false;;
13063   esac
13064
13065   case $ac_option in
13066   # Handling of the options.
13067 _ACEOF
13068 cat >>$CONFIG_STATUS <<\_ACEOF
13069   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13070     ac_cs_recheck=: ;;
13071   --version | --vers* | -V )
13072     echo "$ac_cs_version"; exit 0 ;;
13073   --he | --h)
13074     # Conflict between --help and --header
13075     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13076 Try \`$0 --help' for more information." >&5
13077 echo "$as_me: error: ambiguous option: $1
13078 Try \`$0 --help' for more information." >&2;}
13079    { (exit 1); exit 1; }; };;
13080   --help | --hel | -h )
13081     echo "$ac_cs_usage"; exit 0 ;;
13082   --debug | --d* | -d )
13083     debug=: ;;
13084   --file | --fil | --fi | --f )
13085     $ac_shift
13086     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13087     ac_need_defaults=false;;
13088   --header | --heade | --head | --hea )
13089     $ac_shift
13090     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13091     ac_need_defaults=false;;
13092   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13093   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13094     ac_cs_silent=: ;;
13095
13096   # This is an error.
13097   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13098 Try \`$0 --help' for more information." >&5
13099 echo "$as_me: error: unrecognized option: $1
13100 Try \`$0 --help' for more information." >&2;}
13101    { (exit 1); exit 1; }; } ;;
13102
13103   *) ac_config_targets="$ac_config_targets $1" ;;
13104
13105   esac
13106   shift
13107 done
13108
13109 ac_configure_extra_args=
13110
13111 if $ac_cs_silent; then
13112   exec 6>/dev/null
13113   ac_configure_extra_args="$ac_configure_extra_args --silent"
13114 fi
13115
13116 _ACEOF
13117 cat >>$CONFIG_STATUS <<_ACEOF
13118 if \$ac_cs_recheck; then
13119   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13120   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13121 fi
13122
13123 _ACEOF
13124
13125
13126
13127
13128
13129 cat >>$CONFIG_STATUS <<\_ACEOF
13130 for ac_config_target in $ac_config_targets
13131 do
13132   case "$ac_config_target" in
13133   # Handling of arguments.
13134   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13135   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13136 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13137    { (exit 1); exit 1; }; };;
13138   esac
13139 done
13140
13141 # If the user did not use the arguments to specify the items to instantiate,
13142 # then the envvar interface is used.  Set only those that are not.
13143 # We use the long form for the default assignment because of an extremely
13144 # bizarre bug on SunOS 4.1.3.
13145 if $ac_need_defaults; then
13146   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13147 fi
13148
13149 # Have a temporary directory for convenience.  Make it in the build tree
13150 # simply because there is no reason to put it here, and in addition,
13151 # creating and moving files from /tmp can sometimes cause problems.
13152 # Create a temporary directory, and hook for its removal unless debugging.
13153 $debug ||
13154 {
13155   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13156   trap '{ (exit 1); exit 1; }' 1 2 13 15
13157 }
13158
13159 # Create a (secure) tmp directory for tmp files.
13160
13161 {
13162   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13163   test -n "$tmp" && test -d "$tmp"
13164 }  ||
13165 {
13166   tmp=./confstat$$-$RANDOM
13167   (umask 077 && mkdir $tmp)
13168 } ||
13169 {
13170    echo "$me: cannot create a temporary directory in ." >&2
13171    { (exit 1); exit 1; }
13172 }
13173
13174 _ACEOF
13175
13176 cat >>$CONFIG_STATUS <<_ACEOF
13177
13178 #
13179 # CONFIG_FILES section.
13180 #
13181
13182 # No need to generate the scripts if there are no CONFIG_FILES.
13183 # This happens for instance when ./config.status config.h
13184 if test -n "\$CONFIG_FILES"; then
13185   # Protect against being on the right side of a sed subst in config.status.
13186   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13187    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13188 s,@SHELL@,$SHELL,;t t
13189 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13190 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13191 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13192 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13193 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13194 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13195 s,@exec_prefix@,$exec_prefix,;t t
13196 s,@prefix@,$prefix,;t t
13197 s,@program_transform_name@,$program_transform_name,;t t
13198 s,@bindir@,$bindir,;t t
13199 s,@sbindir@,$sbindir,;t t
13200 s,@libexecdir@,$libexecdir,;t t
13201 s,@datadir@,$datadir,;t t
13202 s,@sysconfdir@,$sysconfdir,;t t
13203 s,@sharedstatedir@,$sharedstatedir,;t t
13204 s,@localstatedir@,$localstatedir,;t t
13205 s,@libdir@,$libdir,;t t
13206 s,@includedir@,$includedir,;t t
13207 s,@oldincludedir@,$oldincludedir,;t t
13208 s,@infodir@,$infodir,;t t
13209 s,@mandir@,$mandir,;t t
13210 s,@build_alias@,$build_alias,;t t
13211 s,@host_alias@,$host_alias,;t t
13212 s,@target_alias@,$target_alias,;t t
13213 s,@DEFS@,$DEFS,;t t
13214 s,@ECHO_C@,$ECHO_C,;t t
13215 s,@ECHO_N@,$ECHO_N,;t t
13216 s,@ECHO_T@,$ECHO_T,;t t
13217 s,@LIBS@,$LIBS,;t t
13218 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13219 s,@build@,$build,;t t
13220 s,@build_cpu@,$build_cpu,;t t
13221 s,@build_vendor@,$build_vendor,;t t
13222 s,@build_os@,$build_os,;t t
13223 s,@build_noncanonical@,$build_noncanonical,;t t
13224 s,@host_noncanonical@,$host_noncanonical,;t t
13225 s,@target_noncanonical@,$target_noncanonical,;t t
13226 s,@host@,$host,;t t
13227 s,@host_cpu@,$host_cpu,;t t
13228 s,@host_vendor@,$host_vendor,;t t
13229 s,@host_os@,$host_os,;t t
13230 s,@target@,$target,;t t
13231 s,@target_cpu@,$target_cpu,;t t
13232 s,@target_vendor@,$target_vendor,;t t
13233 s,@target_os@,$target_os,;t t
13234 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13235 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13236 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13237 s,@LN@,$LN,;t t
13238 s,@LN_S@,$LN_S,;t t
13239 s,@build_libsubdir@,$build_libsubdir,;t t
13240 s,@build_subdir@,$build_subdir,;t t
13241 s,@host_subdir@,$host_subdir,;t t
13242 s,@target_subdir@,$target_subdir,;t t
13243 s,@CC@,$CC,;t t
13244 s,@CFLAGS@,$CFLAGS,;t t
13245 s,@LDFLAGS@,$LDFLAGS,;t t
13246 s,@CPPFLAGS@,$CPPFLAGS,;t t
13247 s,@ac_ct_CC@,$ac_ct_CC,;t t
13248 s,@EXEEXT@,$EXEEXT,;t t
13249 s,@OBJEXT@,$OBJEXT,;t t
13250 s,@CXX@,$CXX,;t t
13251 s,@CXXFLAGS@,$CXXFLAGS,;t t
13252 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13253 s,@GNATBIND@,$GNATBIND,;t t
13254 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13255 s,@GNATMAKE@,$GNATMAKE,;t t
13256 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13257 s,@do_compare@,$do_compare,;t t
13258 s,@gmplibs@,$gmplibs,;t t
13259 s,@gmpinc@,$gmpinc,;t t
13260 s,@extra_mpfr_configure_flags@,$extra_mpfr_configure_flags,;t t
13261 s,@ppllibs@,$ppllibs,;t t
13262 s,@pplinc@,$pplinc,;t t
13263 s,@clooglibs@,$clooglibs,;t t
13264 s,@clooginc@,$clooginc,;t t
13265 s,@stage1_languages@,$stage1_languages,;t t
13266 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13267 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13268 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13269 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13270 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13271 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13272 s,@tooldir@,$tooldir,;t t
13273 s,@build_tooldir@,$build_tooldir,;t t
13274 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13275 s,@GDB_TK@,$GDB_TK,;t t
13276 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13277 s,@build_configargs@,$build_configargs,;t t
13278 s,@build_configdirs@,$build_configdirs,;t t
13279 s,@host_configargs@,$host_configargs,;t t
13280 s,@configdirs@,$configdirs,;t t
13281 s,@target_configargs@,$target_configargs,;t t
13282 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13283 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13284 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13285 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13286 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13287 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13288 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13289 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13290 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13291 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13292 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13293 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13294 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13295 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13296 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13297 s,@config_shell@,$config_shell,;t t
13298 s,@YACC@,$YACC,;t t
13299 s,@BISON@,$BISON,;t t
13300 s,@M4@,$M4,;t t
13301 s,@LEX@,$LEX,;t t
13302 s,@FLEX@,$FLEX,;t t
13303 s,@MAKEINFO@,$MAKEINFO,;t t
13304 s,@EXPECT@,$EXPECT,;t t
13305 s,@RUNTEST@,$RUNTEST,;t t
13306 s,@AR@,$AR,;t t
13307 s,@AS@,$AS,;t t
13308 s,@DLLTOOL@,$DLLTOOL,;t t
13309 s,@LD@,$LD,;t t
13310 s,@LIPO@,$LIPO,;t t
13311 s,@NM@,$NM,;t t
13312 s,@RANLIB@,$RANLIB,;t t
13313 s,@STRIP@,$STRIP,;t t
13314 s,@WINDRES@,$WINDRES,;t t
13315 s,@WINDMC@,$WINDMC,;t t
13316 s,@OBJCOPY@,$OBJCOPY,;t t
13317 s,@OBJDUMP@,$OBJDUMP,;t t
13318 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13319 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13320 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13321 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13322 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13323 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13324 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13325 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13326 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13327 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13328 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13329 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13330 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13331 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13332 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13333 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13334 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13335 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13336 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13337 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13338 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13339 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13340 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13341 s,@MAINT@,$MAINT,;t t
13342 s,@stage1_cflags@,$stage1_cflags,;t t
13343 s,@stage1_checking@,$stage1_checking,;t t
13344 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13345 s,@datarootdir@,$datarootdir,;t t
13346 s,@docdir@,$docdir,;t t
13347 s,@pdfdir@,$pdfdir,;t t
13348 s,@htmldir@,$htmldir,;t t
13349 s,@LIBOBJS@,$LIBOBJS,;t t
13350 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13351 /@serialization_dependencies@/r $serialization_dependencies
13352 s,@serialization_dependencies@,,;t t
13353 /@host_makefile_frag@/r $host_makefile_frag
13354 s,@host_makefile_frag@,,;t t
13355 /@target_makefile_frag@/r $target_makefile_frag
13356 s,@target_makefile_frag@,,;t t
13357 /@alphaieee_frag@/r $alphaieee_frag
13358 s,@alphaieee_frag@,,;t t
13359 /@ospace_frag@/r $ospace_frag
13360 s,@ospace_frag@,,;t t
13361 CEOF
13362
13363 _ACEOF
13364
13365   cat >>$CONFIG_STATUS <<\_ACEOF
13366   # Split the substitutions into bite-sized pieces for seds with
13367   # small command number limits, like on Digital OSF/1 and HP-UX.
13368   ac_max_sed_lines=48
13369   ac_sed_frag=1 # Number of current file.
13370   ac_beg=1 # First line for current file.
13371   ac_end=$ac_max_sed_lines # Line after last line for current file.
13372   ac_more_lines=:
13373   ac_sed_cmds=
13374   while $ac_more_lines; do
13375     if test $ac_beg -gt 1; then
13376       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13377     else
13378       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13379     fi
13380     if test ! -s $tmp/subs.frag; then
13381       ac_more_lines=false
13382     else
13383       # The purpose of the label and of the branching condition is to
13384       # speed up the sed processing (if there are no `@' at all, there
13385       # is no need to browse any of the substitutions).
13386       # These are the two extra sed commands mentioned above.
13387       (echo ':t
13388   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13389       if test -z "$ac_sed_cmds"; then
13390         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13391       else
13392         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13393       fi
13394       ac_sed_frag=`expr $ac_sed_frag + 1`
13395       ac_beg=$ac_end
13396       ac_end=`expr $ac_end + $ac_max_sed_lines`
13397     fi
13398   done
13399   if test -z "$ac_sed_cmds"; then
13400     ac_sed_cmds=cat
13401   fi
13402 fi # test -n "$CONFIG_FILES"
13403
13404 _ACEOF
13405 cat >>$CONFIG_STATUS <<\_ACEOF
13406 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13407   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13408   case $ac_file in
13409   - | *:- | *:-:* ) # input from stdin
13410         cat >$tmp/stdin
13411         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13412         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13413   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13414         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13415   * )   ac_file_in=$ac_file.in ;;
13416   esac
13417
13418   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13419   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13420 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13421          X"$ac_file" : 'X\(//\)[^/]' \| \
13422          X"$ac_file" : 'X\(//\)$' \| \
13423          X"$ac_file" : 'X\(/\)' \| \
13424          .     : '\(.\)' 2>/dev/null ||
13425 echo X"$ac_file" |
13426     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13427           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13428           /^X\(\/\/\)$/{ s//\1/; q; }
13429           /^X\(\/\).*/{ s//\1/; q; }
13430           s/.*/./; q'`
13431   { if $as_mkdir_p; then
13432     mkdir -p "$ac_dir"
13433   else
13434     as_dir="$ac_dir"
13435     as_dirs=
13436     while test ! -d "$as_dir"; do
13437       as_dirs="$as_dir $as_dirs"
13438       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13439 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13440          X"$as_dir" : 'X\(//\)[^/]' \| \
13441          X"$as_dir" : 'X\(//\)$' \| \
13442          X"$as_dir" : 'X\(/\)' \| \
13443          .     : '\(.\)' 2>/dev/null ||
13444 echo X"$as_dir" |
13445     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13446           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13447           /^X\(\/\/\)$/{ s//\1/; q; }
13448           /^X\(\/\).*/{ s//\1/; q; }
13449           s/.*/./; q'`
13450     done
13451     test ! -n "$as_dirs" || mkdir $as_dirs
13452   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13453 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13454    { (exit 1); exit 1; }; }; }
13455
13456   ac_builddir=.
13457
13458 if test "$ac_dir" != .; then
13459   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13460   # A "../" for each directory in $ac_dir_suffix.
13461   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13462 else
13463   ac_dir_suffix= ac_top_builddir=
13464 fi
13465
13466 case $srcdir in
13467   .)  # No --srcdir option.  We are building in place.
13468     ac_srcdir=.
13469     if test -z "$ac_top_builddir"; then
13470        ac_top_srcdir=.
13471     else
13472        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13473     fi ;;
13474   [\\/]* | ?:[\\/]* )  # Absolute path.
13475     ac_srcdir=$srcdir$ac_dir_suffix;
13476     ac_top_srcdir=$srcdir ;;
13477   *) # Relative path.
13478     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13479     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13480 esac
13481
13482 # Do not use `cd foo && pwd` to compute absolute paths, because
13483 # the directories may not exist.
13484 case `pwd` in
13485 .) ac_abs_builddir="$ac_dir";;
13486 *)
13487   case "$ac_dir" in
13488   .) ac_abs_builddir=`pwd`;;
13489   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13490   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13491   esac;;
13492 esac
13493 case $ac_abs_builddir in
13494 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13495 *)
13496   case ${ac_top_builddir}. in
13497   .) ac_abs_top_builddir=$ac_abs_builddir;;
13498   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13499   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13500   esac;;
13501 esac
13502 case $ac_abs_builddir in
13503 .) ac_abs_srcdir=$ac_srcdir;;
13504 *)
13505   case $ac_srcdir in
13506   .) ac_abs_srcdir=$ac_abs_builddir;;
13507   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13508   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13509   esac;;
13510 esac
13511 case $ac_abs_builddir in
13512 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13513 *)
13514   case $ac_top_srcdir in
13515   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13516   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13517   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13518   esac;;
13519 esac
13520
13521
13522   case $INSTALL in
13523   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13524   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13525   esac
13526
13527   if test x"$ac_file" != x-; then
13528     { echo "$as_me:$LINENO: creating $ac_file" >&5
13529 echo "$as_me: creating $ac_file" >&6;}
13530     rm -f "$ac_file"
13531   fi
13532   # Let's still pretend it is `configure' which instantiates (i.e., don't
13533   # use $as_me), people would be surprised to read:
13534   #    /* config.h.  Generated by config.status.  */
13535   if test x"$ac_file" = x-; then
13536     configure_input=
13537   else
13538     configure_input="$ac_file.  "
13539   fi
13540   configure_input=$configure_input"Generated from `echo $ac_file_in |
13541                                      sed 's,.*/,,'` by configure."
13542
13543   # First look for the input files in the build tree, otherwise in the
13544   # src tree.
13545   ac_file_inputs=`IFS=:
13546     for f in $ac_file_in; do
13547       case $f in
13548       -) echo $tmp/stdin ;;
13549       [\\/$]*)
13550          # Absolute (can't be DOS-style, as IFS=:)
13551          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13552 echo "$as_me: error: cannot find input file: $f" >&2;}
13553    { (exit 1); exit 1; }; }
13554          echo "$f";;
13555       *) # Relative
13556          if test -f "$f"; then
13557            # Build tree
13558            echo "$f"
13559          elif test -f "$srcdir/$f"; then
13560            # Source tree
13561            echo "$srcdir/$f"
13562          else
13563            # /dev/null tree
13564            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13565 echo "$as_me: error: cannot find input file: $f" >&2;}
13566    { (exit 1); exit 1; }; }
13567          fi;;
13568       esac
13569     done` || { (exit 1); exit 1; }
13570 _ACEOF
13571 cat >>$CONFIG_STATUS <<_ACEOF
13572   sed "$ac_vpsub
13573 $extrasub
13574 _ACEOF
13575 cat >>$CONFIG_STATUS <<\_ACEOF
13576 :t
13577 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13578 s,@configure_input@,$configure_input,;t t
13579 s,@srcdir@,$ac_srcdir,;t t
13580 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13581 s,@top_srcdir@,$ac_top_srcdir,;t t
13582 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13583 s,@builddir@,$ac_builddir,;t t
13584 s,@abs_builddir@,$ac_abs_builddir,;t t
13585 s,@top_builddir@,$ac_top_builddir,;t t
13586 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13587 s,@INSTALL@,$ac_INSTALL,;t t
13588 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13589   rm -f $tmp/stdin
13590   if test x"$ac_file" != x-; then
13591     mv $tmp/out $ac_file
13592   else
13593     cat $tmp/out
13594     rm -f $tmp/out
13595   fi
13596
13597 done
13598 _ACEOF
13599
13600 cat >>$CONFIG_STATUS <<\_ACEOF
13601
13602 { (exit 0); exit 0; }
13603 _ACEOF
13604 chmod +x $CONFIG_STATUS
13605 ac_clean_files=$ac_clean_files_save
13606
13607
13608 # configure is writing to config.log, and then calls config.status.
13609 # config.status does its own redirection, appending to config.log.
13610 # Unfortunately, on DOS this fails, as config.log is still kept open
13611 # by configure, so config.status won't be able to write to it; its
13612 # output is simply discarded.  So we exec the FD to /dev/null,
13613 # effectively closing config.log, so it can be properly (re)opened and
13614 # appended to by config.status.  When coming back to configure, we
13615 # need to make the FD available again.
13616 if test "$no_create" != yes; then
13617   ac_cs_success=:
13618   ac_config_status_args=
13619   test "$silent" = yes &&
13620     ac_config_status_args="$ac_config_status_args --quiet"
13621   exec 5>/dev/null
13622   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13623   exec 5>>config.log
13624   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13625   # would make configure fail if this is the last instruction.
13626   $ac_cs_success || { (exit 1); exit 1; }
13627 fi
13628